3907 lines
143 KiB
C++
3907 lines
143 KiB
C++
//===--- ExprCXX.h - Classes for representing expressions -------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
///
|
|
/// \file
|
|
/// \brief Defines the clang::Expr interface and subclasses for C++ expressions.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_CLANG_AST_EXPRCXX_H
|
|
#define LLVM_CLANG_AST_EXPRCXX_H
|
|
|
|
#include "clang/AST/Decl.h"
|
|
#include "clang/AST/Expr.h"
|
|
#include "clang/AST/LambdaCapture.h"
|
|
#include "clang/AST/TemplateBase.h"
|
|
#include "clang/AST/UnresolvedSet.h"
|
|
#include "clang/Basic/ExpressionTraits.h"
|
|
#include "clang/Basic/TypeTraits.h"
|
|
#include "llvm/Support/Compiler.h"
|
|
|
|
namespace clang {
|
|
|
|
class CXXConstructorDecl;
|
|
class CXXDestructorDecl;
|
|
class CXXMethodDecl;
|
|
class CXXTemporary;
|
|
class MSPropertyDecl;
|
|
class TemplateArgumentListInfo;
|
|
class UuidAttr;
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// C++ Expressions.
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// \brief A call to an overloaded operator written using operator
|
|
/// syntax.
|
|
///
|
|
/// Represents a call to an overloaded operator written using operator
|
|
/// syntax, e.g., "x + y" or "*p". While semantically equivalent to a
|
|
/// normal call, this AST node provides better information about the
|
|
/// syntactic representation of the call.
|
|
///
|
|
/// In a C++ template, this expression node kind will be used whenever
|
|
/// any of the arguments are type-dependent. In this case, the
|
|
/// function itself will be a (possibly empty) set of functions and
|
|
/// function templates that were found by name lookup at template
|
|
/// definition time.
|
|
class CXXOperatorCallExpr : public CallExpr {
|
|
/// \brief The overloaded operator.
|
|
OverloadedOperatorKind Operator;
|
|
SourceRange Range;
|
|
|
|
// Record the FP_CONTRACT state that applies to this operator call. Only
|
|
// meaningful for floating point types. For other types this value can be
|
|
// set to false.
|
|
unsigned FPContractable : 1;
|
|
|
|
SourceRange getSourceRangeImpl() const LLVM_READONLY;
|
|
public:
|
|
CXXOperatorCallExpr(ASTContext& C, OverloadedOperatorKind Op, Expr *fn,
|
|
ArrayRef<Expr*> args, QualType t, ExprValueKind VK,
|
|
SourceLocation operatorloc, bool fpContractable)
|
|
: CallExpr(C, CXXOperatorCallExprClass, fn, 0, args, t, VK,
|
|
operatorloc),
|
|
Operator(Op), FPContractable(fpContractable) {
|
|
Range = getSourceRangeImpl();
|
|
}
|
|
explicit CXXOperatorCallExpr(ASTContext& C, EmptyShell Empty) :
|
|
CallExpr(C, CXXOperatorCallExprClass, Empty) { }
|
|
|
|
|
|
/// \brief Returns the kind of overloaded operator that this
|
|
/// expression refers to.
|
|
OverloadedOperatorKind getOperator() const { return Operator; }
|
|
|
|
/// \brief Returns the location of the operator symbol in the expression.
|
|
///
|
|
/// When \c getOperator()==OO_Call, this is the location of the right
|
|
/// parentheses; when \c getOperator()==OO_Subscript, this is the location
|
|
/// of the right bracket.
|
|
SourceLocation getOperatorLoc() const { return getRParenLoc(); }
|
|
|
|
SourceLocation getExprLoc() const LLVM_READONLY {
|
|
return (Operator < OO_Plus || Operator >= OO_Arrow ||
|
|
Operator == OO_PlusPlus || Operator == OO_MinusMinus)
|
|
? getLocStart()
|
|
: getOperatorLoc();
|
|
}
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY { return Range.getBegin(); }
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return Range.getEnd(); }
|
|
SourceRange getSourceRange() const { return Range; }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXOperatorCallExprClass;
|
|
}
|
|
|
|
// Set the FP contractability status of this operator. Only meaningful for
|
|
// operations on floating point types.
|
|
void setFPContractable(bool FPC) { FPContractable = FPC; }
|
|
|
|
// Get the FP contractability status of this operator. Only meaningful for
|
|
// operations on floating point types.
|
|
bool isFPContractable() const { return FPContractable; }
|
|
|
|
friend class ASTStmtReader;
|
|
friend class ASTStmtWriter;
|
|
};
|
|
|
|
/// Represents a call to a member function that
|
|
/// may be written either with member call syntax (e.g., "obj.func()"
|
|
/// or "objptr->func()") or with normal function-call syntax
|
|
/// ("func()") within a member function that ends up calling a member
|
|
/// function. The callee in either case is a MemberExpr that contains
|
|
/// both the object argument and the member function, while the
|
|
/// arguments are the arguments within the parentheses (not including
|
|
/// the object argument).
|
|
class CXXMemberCallExpr : public CallExpr {
|
|
public:
|
|
CXXMemberCallExpr(ASTContext &C, Expr *fn, ArrayRef<Expr*> args,
|
|
QualType t, ExprValueKind VK, SourceLocation RP)
|
|
: CallExpr(C, CXXMemberCallExprClass, fn, 0, args, t, VK, RP) {}
|
|
|
|
CXXMemberCallExpr(ASTContext &C, EmptyShell Empty)
|
|
: CallExpr(C, CXXMemberCallExprClass, Empty) { }
|
|
|
|
/// \brief Retrieves the implicit object argument for the member call.
|
|
///
|
|
/// For example, in "x.f(5)", this returns the sub-expression "x".
|
|
Expr *getImplicitObjectArgument() const;
|
|
|
|
/// \brief Retrieves the declaration of the called method.
|
|
CXXMethodDecl *getMethodDecl() const;
|
|
|
|
/// \brief Retrieves the CXXRecordDecl for the underlying type of
|
|
/// the implicit object argument.
|
|
///
|
|
/// Note that this is may not be the same declaration as that of the class
|
|
/// context of the CXXMethodDecl which this function is calling.
|
|
/// FIXME: Returns 0 for member pointer call exprs.
|
|
CXXRecordDecl *getRecordDecl() const;
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXMemberCallExprClass;
|
|
}
|
|
};
|
|
|
|
/// \brief Represents a call to a CUDA kernel function.
|
|
class CUDAKernelCallExpr : public CallExpr {
|
|
private:
|
|
enum { CONFIG, END_PREARG };
|
|
|
|
public:
|
|
CUDAKernelCallExpr(ASTContext &C, Expr *fn, CallExpr *Config,
|
|
ArrayRef<Expr*> args, QualType t, ExprValueKind VK,
|
|
SourceLocation RP)
|
|
: CallExpr(C, CUDAKernelCallExprClass, fn, END_PREARG, args, t, VK, RP) {
|
|
setConfig(Config);
|
|
}
|
|
|
|
CUDAKernelCallExpr(ASTContext &C, EmptyShell Empty)
|
|
: CallExpr(C, CUDAKernelCallExprClass, END_PREARG, Empty) { }
|
|
|
|
const CallExpr *getConfig() const {
|
|
return cast_or_null<CallExpr>(getPreArg(CONFIG));
|
|
}
|
|
CallExpr *getConfig() { return cast_or_null<CallExpr>(getPreArg(CONFIG)); }
|
|
void setConfig(CallExpr *E) { setPreArg(CONFIG, E); }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CUDAKernelCallExprClass;
|
|
}
|
|
};
|
|
|
|
/// \brief Abstract class common to all of the C++ "named"/"keyword" casts.
|
|
///
|
|
/// This abstract class is inherited by all of the classes
|
|
/// representing "named" casts: CXXStaticCastExpr for \c static_cast,
|
|
/// CXXDynamicCastExpr for \c dynamic_cast, CXXReinterpretCastExpr for
|
|
/// reinterpret_cast, and CXXConstCastExpr for \c const_cast.
|
|
class CXXNamedCastExpr : public ExplicitCastExpr {
|
|
private:
|
|
SourceLocation Loc; // the location of the casting op
|
|
SourceLocation RParenLoc; // the location of the right parenthesis
|
|
SourceRange AngleBrackets; // range for '<' '>'
|
|
|
|
protected:
|
|
CXXNamedCastExpr(StmtClass SC, QualType ty, ExprValueKind VK,
|
|
CastKind kind, Expr *op, unsigned PathSize,
|
|
TypeSourceInfo *writtenTy, SourceLocation l,
|
|
SourceLocation RParenLoc,
|
|
SourceRange AngleBrackets)
|
|
: ExplicitCastExpr(SC, ty, VK, kind, op, PathSize, writtenTy), Loc(l),
|
|
RParenLoc(RParenLoc), AngleBrackets(AngleBrackets) {}
|
|
|
|
explicit CXXNamedCastExpr(StmtClass SC, EmptyShell Shell, unsigned PathSize)
|
|
: ExplicitCastExpr(SC, Shell, PathSize) { }
|
|
|
|
friend class ASTStmtReader;
|
|
|
|
public:
|
|
const char *getCastName() const;
|
|
|
|
/// \brief Retrieve the location of the cast operator keyword, e.g.,
|
|
/// \c static_cast.
|
|
SourceLocation getOperatorLoc() const { return Loc; }
|
|
|
|
/// \brief Retrieve the location of the closing parenthesis.
|
|
SourceLocation getRParenLoc() const { return RParenLoc; }
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return RParenLoc; }
|
|
SourceRange getAngleBrackets() const LLVM_READONLY { return AngleBrackets; }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
switch (T->getStmtClass()) {
|
|
case CXXStaticCastExprClass:
|
|
case CXXDynamicCastExprClass:
|
|
case CXXReinterpretCastExprClass:
|
|
case CXXConstCastExprClass:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
|
|
/// \brief A C++ \c static_cast expression (C++ [expr.static.cast]).
|
|
///
|
|
/// This expression node represents a C++ static cast, e.g.,
|
|
/// \c static_cast<int>(1.0).
|
|
class CXXStaticCastExpr : public CXXNamedCastExpr {
|
|
CXXStaticCastExpr(QualType ty, ExprValueKind vk, CastKind kind, Expr *op,
|
|
unsigned pathSize, TypeSourceInfo *writtenTy,
|
|
SourceLocation l, SourceLocation RParenLoc,
|
|
SourceRange AngleBrackets)
|
|
: CXXNamedCastExpr(CXXStaticCastExprClass, ty, vk, kind, op, pathSize,
|
|
writtenTy, l, RParenLoc, AngleBrackets) {}
|
|
|
|
explicit CXXStaticCastExpr(EmptyShell Empty, unsigned PathSize)
|
|
: CXXNamedCastExpr(CXXStaticCastExprClass, Empty, PathSize) { }
|
|
|
|
public:
|
|
static CXXStaticCastExpr *Create(const ASTContext &Context, QualType T,
|
|
ExprValueKind VK, CastKind K, Expr *Op,
|
|
const CXXCastPath *Path,
|
|
TypeSourceInfo *Written, SourceLocation L,
|
|
SourceLocation RParenLoc,
|
|
SourceRange AngleBrackets);
|
|
static CXXStaticCastExpr *CreateEmpty(const ASTContext &Context,
|
|
unsigned PathSize);
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXStaticCastExprClass;
|
|
}
|
|
};
|
|
|
|
/// \brief A C++ @c dynamic_cast expression (C++ [expr.dynamic.cast]).
|
|
///
|
|
/// This expression node represents a dynamic cast, e.g.,
|
|
/// \c dynamic_cast<Derived*>(BasePtr). Such a cast may perform a run-time
|
|
/// check to determine how to perform the type conversion.
|
|
class CXXDynamicCastExpr : public CXXNamedCastExpr {
|
|
CXXDynamicCastExpr(QualType ty, ExprValueKind VK, CastKind kind,
|
|
Expr *op, unsigned pathSize, TypeSourceInfo *writtenTy,
|
|
SourceLocation l, SourceLocation RParenLoc,
|
|
SourceRange AngleBrackets)
|
|
: CXXNamedCastExpr(CXXDynamicCastExprClass, ty, VK, kind, op, pathSize,
|
|
writtenTy, l, RParenLoc, AngleBrackets) {}
|
|
|
|
explicit CXXDynamicCastExpr(EmptyShell Empty, unsigned pathSize)
|
|
: CXXNamedCastExpr(CXXDynamicCastExprClass, Empty, pathSize) { }
|
|
|
|
public:
|
|
static CXXDynamicCastExpr *Create(const ASTContext &Context, QualType T,
|
|
ExprValueKind VK, CastKind Kind, Expr *Op,
|
|
const CXXCastPath *Path,
|
|
TypeSourceInfo *Written, SourceLocation L,
|
|
SourceLocation RParenLoc,
|
|
SourceRange AngleBrackets);
|
|
|
|
static CXXDynamicCastExpr *CreateEmpty(const ASTContext &Context,
|
|
unsigned pathSize);
|
|
|
|
bool isAlwaysNull() const;
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXDynamicCastExprClass;
|
|
}
|
|
};
|
|
|
|
/// \brief A C++ @c reinterpret_cast expression (C++ [expr.reinterpret.cast]).
|
|
///
|
|
/// This expression node represents a reinterpret cast, e.g.,
|
|
/// @c reinterpret_cast<int>(VoidPtr).
|
|
///
|
|
/// A reinterpret_cast provides a differently-typed view of a value but
|
|
/// (in Clang, as in most C++ implementations) performs no actual work at
|
|
/// run time.
|
|
class CXXReinterpretCastExpr : public CXXNamedCastExpr {
|
|
CXXReinterpretCastExpr(QualType ty, ExprValueKind vk, CastKind kind,
|
|
Expr *op, unsigned pathSize,
|
|
TypeSourceInfo *writtenTy, SourceLocation l,
|
|
SourceLocation RParenLoc,
|
|
SourceRange AngleBrackets)
|
|
: CXXNamedCastExpr(CXXReinterpretCastExprClass, ty, vk, kind, op,
|
|
pathSize, writtenTy, l, RParenLoc, AngleBrackets) {}
|
|
|
|
CXXReinterpretCastExpr(EmptyShell Empty, unsigned pathSize)
|
|
: CXXNamedCastExpr(CXXReinterpretCastExprClass, Empty, pathSize) { }
|
|
|
|
public:
|
|
static CXXReinterpretCastExpr *Create(const ASTContext &Context, QualType T,
|
|
ExprValueKind VK, CastKind Kind,
|
|
Expr *Op, const CXXCastPath *Path,
|
|
TypeSourceInfo *WrittenTy, SourceLocation L,
|
|
SourceLocation RParenLoc,
|
|
SourceRange AngleBrackets);
|
|
static CXXReinterpretCastExpr *CreateEmpty(const ASTContext &Context,
|
|
unsigned pathSize);
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXReinterpretCastExprClass;
|
|
}
|
|
};
|
|
|
|
/// \brief A C++ \c const_cast expression (C++ [expr.const.cast]).
|
|
///
|
|
/// This expression node represents a const cast, e.g.,
|
|
/// \c const_cast<char*>(PtrToConstChar).
|
|
///
|
|
/// A const_cast can remove type qualifiers but does not change the underlying
|
|
/// value.
|
|
class CXXConstCastExpr : public CXXNamedCastExpr {
|
|
CXXConstCastExpr(QualType ty, ExprValueKind VK, Expr *op,
|
|
TypeSourceInfo *writtenTy, SourceLocation l,
|
|
SourceLocation RParenLoc, SourceRange AngleBrackets)
|
|
: CXXNamedCastExpr(CXXConstCastExprClass, ty, VK, CK_NoOp, op,
|
|
0, writtenTy, l, RParenLoc, AngleBrackets) {}
|
|
|
|
explicit CXXConstCastExpr(EmptyShell Empty)
|
|
: CXXNamedCastExpr(CXXConstCastExprClass, Empty, 0) { }
|
|
|
|
public:
|
|
static CXXConstCastExpr *Create(const ASTContext &Context, QualType T,
|
|
ExprValueKind VK, Expr *Op,
|
|
TypeSourceInfo *WrittenTy, SourceLocation L,
|
|
SourceLocation RParenLoc,
|
|
SourceRange AngleBrackets);
|
|
static CXXConstCastExpr *CreateEmpty(const ASTContext &Context);
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXConstCastExprClass;
|
|
}
|
|
};
|
|
|
|
/// \brief A call to a literal operator (C++11 [over.literal])
|
|
/// written as a user-defined literal (C++11 [lit.ext]).
|
|
///
|
|
/// Represents a user-defined literal, e.g. "foo"_bar or 1.23_xyz. While this
|
|
/// is semantically equivalent to a normal call, this AST node provides better
|
|
/// information about the syntactic representation of the literal.
|
|
///
|
|
/// Since literal operators are never found by ADL and can only be declared at
|
|
/// namespace scope, a user-defined literal is never dependent.
|
|
class UserDefinedLiteral : public CallExpr {
|
|
/// \brief The location of a ud-suffix within the literal.
|
|
SourceLocation UDSuffixLoc;
|
|
|
|
public:
|
|
UserDefinedLiteral(const ASTContext &C, Expr *Fn, ArrayRef<Expr*> Args,
|
|
QualType T, ExprValueKind VK, SourceLocation LitEndLoc,
|
|
SourceLocation SuffixLoc)
|
|
: CallExpr(C, UserDefinedLiteralClass, Fn, 0, Args, T, VK, LitEndLoc),
|
|
UDSuffixLoc(SuffixLoc) {}
|
|
explicit UserDefinedLiteral(const ASTContext &C, EmptyShell Empty)
|
|
: CallExpr(C, UserDefinedLiteralClass, Empty) {}
|
|
|
|
/// The kind of literal operator which is invoked.
|
|
enum LiteralOperatorKind {
|
|
LOK_Raw, ///< Raw form: operator "" X (const char *)
|
|
LOK_Template, ///< Raw form: operator "" X<cs...> ()
|
|
LOK_Integer, ///< operator "" X (unsigned long long)
|
|
LOK_Floating, ///< operator "" X (long double)
|
|
LOK_String, ///< operator "" X (const CharT *, size_t)
|
|
LOK_Character ///< operator "" X (CharT)
|
|
};
|
|
|
|
/// \brief Returns the kind of literal operator invocation
|
|
/// which this expression represents.
|
|
LiteralOperatorKind getLiteralOperatorKind() const;
|
|
|
|
/// \brief If this is not a raw user-defined literal, get the
|
|
/// underlying cooked literal (representing the literal with the suffix
|
|
/// removed).
|
|
Expr *getCookedLiteral();
|
|
const Expr *getCookedLiteral() const {
|
|
return const_cast<UserDefinedLiteral*>(this)->getCookedLiteral();
|
|
}
|
|
|
|
SourceLocation getLocStart() const {
|
|
if (getLiteralOperatorKind() == LOK_Template)
|
|
return getRParenLoc();
|
|
return getArg(0)->getLocStart();
|
|
}
|
|
SourceLocation getLocEnd() const { return getRParenLoc(); }
|
|
|
|
|
|
/// \brief Returns the location of a ud-suffix in the expression.
|
|
///
|
|
/// For a string literal, there may be multiple identical suffixes. This
|
|
/// returns the first.
|
|
SourceLocation getUDSuffixLoc() const { return UDSuffixLoc; }
|
|
|
|
/// \brief Returns the ud-suffix specified for this literal.
|
|
const IdentifierInfo *getUDSuffix() const;
|
|
|
|
static bool classof(const Stmt *S) {
|
|
return S->getStmtClass() == UserDefinedLiteralClass;
|
|
}
|
|
|
|
friend class ASTStmtReader;
|
|
friend class ASTStmtWriter;
|
|
};
|
|
|
|
/// \brief A boolean literal, per ([C++ lex.bool] Boolean literals).
|
|
///
|
|
class CXXBoolLiteralExpr : public Expr {
|
|
bool Value;
|
|
SourceLocation Loc;
|
|
public:
|
|
CXXBoolLiteralExpr(bool val, QualType Ty, SourceLocation l) :
|
|
Expr(CXXBoolLiteralExprClass, Ty, VK_RValue, OK_Ordinary, false, false,
|
|
false, false),
|
|
Value(val), Loc(l) {}
|
|
|
|
explicit CXXBoolLiteralExpr(EmptyShell Empty)
|
|
: Expr(CXXBoolLiteralExprClass, Empty) { }
|
|
|
|
bool getValue() const { return Value; }
|
|
void setValue(bool V) { Value = V; }
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return Loc; }
|
|
|
|
SourceLocation getLocation() const { return Loc; }
|
|
void setLocation(SourceLocation L) { Loc = L; }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXBoolLiteralExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() { return child_range(); }
|
|
};
|
|
|
|
/// \brief The null pointer literal (C++11 [lex.nullptr])
|
|
///
|
|
/// Introduced in C++11, the only literal of type \c nullptr_t is \c nullptr.
|
|
class CXXNullPtrLiteralExpr : public Expr {
|
|
SourceLocation Loc;
|
|
public:
|
|
CXXNullPtrLiteralExpr(QualType Ty, SourceLocation l) :
|
|
Expr(CXXNullPtrLiteralExprClass, Ty, VK_RValue, OK_Ordinary, false, false,
|
|
false, false),
|
|
Loc(l) {}
|
|
|
|
explicit CXXNullPtrLiteralExpr(EmptyShell Empty)
|
|
: Expr(CXXNullPtrLiteralExprClass, Empty) { }
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return Loc; }
|
|
|
|
SourceLocation getLocation() const { return Loc; }
|
|
void setLocation(SourceLocation L) { Loc = L; }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXNullPtrLiteralExprClass;
|
|
}
|
|
|
|
child_range children() { return child_range(); }
|
|
};
|
|
|
|
/// \brief Implicit construction of a std::initializer_list<T> object from an
|
|
/// array temporary within list-initialization (C++11 [dcl.init.list]p5).
|
|
class CXXStdInitializerListExpr : public Expr {
|
|
Stmt *SubExpr;
|
|
|
|
CXXStdInitializerListExpr(EmptyShell Empty)
|
|
: Expr(CXXStdInitializerListExprClass, Empty), SubExpr(nullptr) {}
|
|
|
|
public:
|
|
CXXStdInitializerListExpr(QualType Ty, Expr *SubExpr)
|
|
: Expr(CXXStdInitializerListExprClass, Ty, VK_RValue, OK_Ordinary,
|
|
Ty->isDependentType(), SubExpr->isValueDependent(),
|
|
SubExpr->isInstantiationDependent(),
|
|
SubExpr->containsUnexpandedParameterPack()),
|
|
SubExpr(SubExpr) {}
|
|
|
|
Expr *getSubExpr() { return static_cast<Expr*>(SubExpr); }
|
|
const Expr *getSubExpr() const { return static_cast<const Expr*>(SubExpr); }
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY {
|
|
return SubExpr->getLocStart();
|
|
}
|
|
SourceLocation getLocEnd() const LLVM_READONLY {
|
|
return SubExpr->getLocEnd();
|
|
}
|
|
SourceRange getSourceRange() const LLVM_READONLY {
|
|
return SubExpr->getSourceRange();
|
|
}
|
|
|
|
static bool classof(const Stmt *S) {
|
|
return S->getStmtClass() == CXXStdInitializerListExprClass;
|
|
}
|
|
|
|
child_range children() { return child_range(&SubExpr, &SubExpr + 1); }
|
|
|
|
friend class ASTReader;
|
|
friend class ASTStmtReader;
|
|
};
|
|
|
|
/// A C++ \c typeid expression (C++ [expr.typeid]), which gets
|
|
/// the \c type_info that corresponds to the supplied type, or the (possibly
|
|
/// dynamic) type of the supplied expression.
|
|
///
|
|
/// This represents code like \c typeid(int) or \c typeid(*objPtr)
|
|
class CXXTypeidExpr : public Expr {
|
|
private:
|
|
llvm::PointerUnion<Stmt *, TypeSourceInfo *> Operand;
|
|
SourceRange Range;
|
|
|
|
public:
|
|
CXXTypeidExpr(QualType Ty, TypeSourceInfo *Operand, SourceRange R)
|
|
: Expr(CXXTypeidExprClass, Ty, VK_LValue, OK_Ordinary,
|
|
// typeid is never type-dependent (C++ [temp.dep.expr]p4)
|
|
false,
|
|
// typeid is value-dependent if the type or expression are dependent
|
|
Operand->getType()->isDependentType(),
|
|
Operand->getType()->isInstantiationDependentType(),
|
|
Operand->getType()->containsUnexpandedParameterPack()),
|
|
Operand(Operand), Range(R) { }
|
|
|
|
CXXTypeidExpr(QualType Ty, Expr *Operand, SourceRange R)
|
|
: Expr(CXXTypeidExprClass, Ty, VK_LValue, OK_Ordinary,
|
|
// typeid is never type-dependent (C++ [temp.dep.expr]p4)
|
|
false,
|
|
// typeid is value-dependent if the type or expression are dependent
|
|
Operand->isTypeDependent() || Operand->isValueDependent(),
|
|
Operand->isInstantiationDependent(),
|
|
Operand->containsUnexpandedParameterPack()),
|
|
Operand(Operand), Range(R) { }
|
|
|
|
CXXTypeidExpr(EmptyShell Empty, bool isExpr)
|
|
: Expr(CXXTypeidExprClass, Empty) {
|
|
if (isExpr)
|
|
Operand = (Expr*)nullptr;
|
|
else
|
|
Operand = (TypeSourceInfo*)nullptr;
|
|
}
|
|
|
|
/// Determine whether this typeid has a type operand which is potentially
|
|
/// evaluated, per C++11 [expr.typeid]p3.
|
|
bool isPotentiallyEvaluated() const;
|
|
|
|
bool isTypeOperand() const { return Operand.is<TypeSourceInfo *>(); }
|
|
|
|
/// \brief Retrieves the type operand of this typeid() expression after
|
|
/// various required adjustments (removing reference types, cv-qualifiers).
|
|
QualType getTypeOperand(ASTContext &Context) const;
|
|
|
|
/// \brief Retrieve source information for the type operand.
|
|
TypeSourceInfo *getTypeOperandSourceInfo() const {
|
|
assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)");
|
|
return Operand.get<TypeSourceInfo *>();
|
|
}
|
|
|
|
void setTypeOperandSourceInfo(TypeSourceInfo *TSI) {
|
|
assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)");
|
|
Operand = TSI;
|
|
}
|
|
|
|
Expr *getExprOperand() const {
|
|
assert(!isTypeOperand() && "Cannot call getExprOperand for typeid(type)");
|
|
return static_cast<Expr*>(Operand.get<Stmt *>());
|
|
}
|
|
|
|
void setExprOperand(Expr *E) {
|
|
assert(!isTypeOperand() && "Cannot call getExprOperand for typeid(type)");
|
|
Operand = E;
|
|
}
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY { return Range.getBegin(); }
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return Range.getEnd(); }
|
|
SourceRange getSourceRange() const LLVM_READONLY { return Range; }
|
|
void setSourceRange(SourceRange R) { Range = R; }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXTypeidExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() {
|
|
if (isTypeOperand()) return child_range();
|
|
Stmt **begin = reinterpret_cast<Stmt**>(&Operand);
|
|
return child_range(begin, begin + 1);
|
|
}
|
|
};
|
|
|
|
/// \brief A member reference to an MSPropertyDecl.
|
|
///
|
|
/// This expression always has pseudo-object type, and therefore it is
|
|
/// typically not encountered in a fully-typechecked expression except
|
|
/// within the syntactic form of a PseudoObjectExpr.
|
|
class MSPropertyRefExpr : public Expr {
|
|
Expr *BaseExpr;
|
|
MSPropertyDecl *TheDecl;
|
|
SourceLocation MemberLoc;
|
|
bool IsArrow;
|
|
NestedNameSpecifierLoc QualifierLoc;
|
|
|
|
public:
|
|
MSPropertyRefExpr(Expr *baseExpr, MSPropertyDecl *decl, bool isArrow,
|
|
QualType ty, ExprValueKind VK,
|
|
NestedNameSpecifierLoc qualifierLoc,
|
|
SourceLocation nameLoc)
|
|
: Expr(MSPropertyRefExprClass, ty, VK, OK_Ordinary,
|
|
/*type-dependent*/ false, baseExpr->isValueDependent(),
|
|
baseExpr->isInstantiationDependent(),
|
|
baseExpr->containsUnexpandedParameterPack()),
|
|
BaseExpr(baseExpr), TheDecl(decl),
|
|
MemberLoc(nameLoc), IsArrow(isArrow),
|
|
QualifierLoc(qualifierLoc) {}
|
|
|
|
MSPropertyRefExpr(EmptyShell Empty) : Expr(MSPropertyRefExprClass, Empty) {}
|
|
|
|
SourceRange getSourceRange() const LLVM_READONLY {
|
|
return SourceRange(getLocStart(), getLocEnd());
|
|
}
|
|
bool isImplicitAccess() const {
|
|
return getBaseExpr() && getBaseExpr()->isImplicitCXXThis();
|
|
}
|
|
SourceLocation getLocStart() const {
|
|
if (!isImplicitAccess())
|
|
return BaseExpr->getLocStart();
|
|
else if (QualifierLoc)
|
|
return QualifierLoc.getBeginLoc();
|
|
else
|
|
return MemberLoc;
|
|
}
|
|
SourceLocation getLocEnd() const { return getMemberLoc(); }
|
|
|
|
child_range children() {
|
|
return child_range((Stmt**)&BaseExpr, (Stmt**)&BaseExpr + 1);
|
|
}
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == MSPropertyRefExprClass;
|
|
}
|
|
|
|
Expr *getBaseExpr() const { return BaseExpr; }
|
|
MSPropertyDecl *getPropertyDecl() const { return TheDecl; }
|
|
bool isArrow() const { return IsArrow; }
|
|
SourceLocation getMemberLoc() const { return MemberLoc; }
|
|
NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
|
|
|
|
friend class ASTStmtReader;
|
|
};
|
|
|
|
/// A Microsoft C++ @c __uuidof expression, which gets
|
|
/// the _GUID that corresponds to the supplied type or expression.
|
|
///
|
|
/// This represents code like @c __uuidof(COMTYPE) or @c __uuidof(*comPtr)
|
|
class CXXUuidofExpr : public Expr {
|
|
private:
|
|
llvm::PointerUnion<Stmt *, TypeSourceInfo *> Operand;
|
|
SourceRange Range;
|
|
|
|
public:
|
|
CXXUuidofExpr(QualType Ty, TypeSourceInfo *Operand, SourceRange R)
|
|
: Expr(CXXUuidofExprClass, Ty, VK_LValue, OK_Ordinary,
|
|
false, Operand->getType()->isDependentType(),
|
|
Operand->getType()->isInstantiationDependentType(),
|
|
Operand->getType()->containsUnexpandedParameterPack()),
|
|
Operand(Operand), Range(R) { }
|
|
|
|
CXXUuidofExpr(QualType Ty, Expr *Operand, SourceRange R)
|
|
: Expr(CXXUuidofExprClass, Ty, VK_LValue, OK_Ordinary,
|
|
false, Operand->isTypeDependent(),
|
|
Operand->isInstantiationDependent(),
|
|
Operand->containsUnexpandedParameterPack()),
|
|
Operand(Operand), Range(R) { }
|
|
|
|
CXXUuidofExpr(EmptyShell Empty, bool isExpr)
|
|
: Expr(CXXUuidofExprClass, Empty) {
|
|
if (isExpr)
|
|
Operand = (Expr*)nullptr;
|
|
else
|
|
Operand = (TypeSourceInfo*)nullptr;
|
|
}
|
|
|
|
bool isTypeOperand() const { return Operand.is<TypeSourceInfo *>(); }
|
|
|
|
/// \brief Retrieves the type operand of this __uuidof() expression after
|
|
/// various required adjustments (removing reference types, cv-qualifiers).
|
|
QualType getTypeOperand(ASTContext &Context) const;
|
|
|
|
/// \brief Retrieve source information for the type operand.
|
|
TypeSourceInfo *getTypeOperandSourceInfo() const {
|
|
assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)");
|
|
return Operand.get<TypeSourceInfo *>();
|
|
}
|
|
|
|
void setTypeOperandSourceInfo(TypeSourceInfo *TSI) {
|
|
assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)");
|
|
Operand = TSI;
|
|
}
|
|
|
|
Expr *getExprOperand() const {
|
|
assert(!isTypeOperand() && "Cannot call getExprOperand for __uuidof(type)");
|
|
return static_cast<Expr*>(Operand.get<Stmt *>());
|
|
}
|
|
|
|
void setExprOperand(Expr *E) {
|
|
assert(!isTypeOperand() && "Cannot call getExprOperand for __uuidof(type)");
|
|
Operand = E;
|
|
}
|
|
|
|
StringRef getUuidAsStringRef(ASTContext &Context) const;
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY { return Range.getBegin(); }
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return Range.getEnd(); }
|
|
SourceRange getSourceRange() const LLVM_READONLY { return Range; }
|
|
void setSourceRange(SourceRange R) { Range = R; }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXUuidofExprClass;
|
|
}
|
|
|
|
/// Grabs __declspec(uuid()) off a type, or returns 0 if we cannot resolve to
|
|
/// a single GUID.
|
|
static const UuidAttr *GetUuidAttrOfType(QualType QT,
|
|
bool *HasMultipleGUIDsPtr = nullptr);
|
|
|
|
// Iterators
|
|
child_range children() {
|
|
if (isTypeOperand()) return child_range();
|
|
Stmt **begin = reinterpret_cast<Stmt**>(&Operand);
|
|
return child_range(begin, begin + 1);
|
|
}
|
|
};
|
|
|
|
/// \brief Represents the \c this expression in C++.
|
|
///
|
|
/// This is a pointer to the object on which the current member function is
|
|
/// executing (C++ [expr.prim]p3). Example:
|
|
///
|
|
/// \code
|
|
/// class Foo {
|
|
/// public:
|
|
/// void bar();
|
|
/// void test() { this->bar(); }
|
|
/// };
|
|
/// \endcode
|
|
class CXXThisExpr : public Expr {
|
|
SourceLocation Loc;
|
|
bool Implicit : 1;
|
|
|
|
public:
|
|
CXXThisExpr(SourceLocation L, QualType Type, bool isImplicit)
|
|
: Expr(CXXThisExprClass, Type, VK_RValue, OK_Ordinary,
|
|
// 'this' is type-dependent if the class type of the enclosing
|
|
// member function is dependent (C++ [temp.dep.expr]p2)
|
|
Type->isDependentType(), Type->isDependentType(),
|
|
Type->isInstantiationDependentType(),
|
|
/*ContainsUnexpandedParameterPack=*/false),
|
|
Loc(L), Implicit(isImplicit) { }
|
|
|
|
CXXThisExpr(EmptyShell Empty) : Expr(CXXThisExprClass, Empty) {}
|
|
|
|
SourceLocation getLocation() const { return Loc; }
|
|
void setLocation(SourceLocation L) { Loc = L; }
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return Loc; }
|
|
|
|
bool isImplicit() const { return Implicit; }
|
|
void setImplicit(bool I) { Implicit = I; }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXThisExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() { return child_range(); }
|
|
};
|
|
|
|
/// \brief A C++ throw-expression (C++ [except.throw]).
|
|
///
|
|
/// This handles 'throw' (for re-throwing the current exception) and
|
|
/// 'throw' assignment-expression. When assignment-expression isn't
|
|
/// present, Op will be null.
|
|
class CXXThrowExpr : public Expr {
|
|
Stmt *Op;
|
|
SourceLocation ThrowLoc;
|
|
/// \brief Whether the thrown variable (if any) is in scope.
|
|
unsigned IsThrownVariableInScope : 1;
|
|
|
|
friend class ASTStmtReader;
|
|
|
|
public:
|
|
// \p Ty is the void type which is used as the result type of the
|
|
// expression. The \p l is the location of the throw keyword. \p expr
|
|
// can by null, if the optional expression to throw isn't present.
|
|
CXXThrowExpr(Expr *expr, QualType Ty, SourceLocation l,
|
|
bool IsThrownVariableInScope) :
|
|
Expr(CXXThrowExprClass, Ty, VK_RValue, OK_Ordinary, false, false,
|
|
expr && expr->isInstantiationDependent(),
|
|
expr && expr->containsUnexpandedParameterPack()),
|
|
Op(expr), ThrowLoc(l), IsThrownVariableInScope(IsThrownVariableInScope) {}
|
|
CXXThrowExpr(EmptyShell Empty) : Expr(CXXThrowExprClass, Empty) {}
|
|
|
|
const Expr *getSubExpr() const { return cast_or_null<Expr>(Op); }
|
|
Expr *getSubExpr() { return cast_or_null<Expr>(Op); }
|
|
|
|
SourceLocation getThrowLoc() const { return ThrowLoc; }
|
|
|
|
/// \brief Determines whether the variable thrown by this expression (if any!)
|
|
/// is within the innermost try block.
|
|
///
|
|
/// This information is required to determine whether the NRVO can apply to
|
|
/// this variable.
|
|
bool isThrownVariableInScope() const { return IsThrownVariableInScope; }
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY { return ThrowLoc; }
|
|
SourceLocation getLocEnd() const LLVM_READONLY {
|
|
if (!getSubExpr())
|
|
return ThrowLoc;
|
|
return getSubExpr()->getLocEnd();
|
|
}
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXThrowExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() {
|
|
return child_range(&Op, Op ? &Op+1 : &Op);
|
|
}
|
|
};
|
|
|
|
/// \brief A default argument (C++ [dcl.fct.default]).
|
|
///
|
|
/// This wraps up a function call argument that was created from the
|
|
/// corresponding parameter's default argument, when the call did not
|
|
/// explicitly supply arguments for all of the parameters.
|
|
class CXXDefaultArgExpr : public Expr {
|
|
/// \brief The parameter whose default is being used.
|
|
///
|
|
/// When the bit is set, the subexpression is stored after the
|
|
/// CXXDefaultArgExpr itself. When the bit is clear, the parameter's
|
|
/// actual default expression is the subexpression.
|
|
llvm::PointerIntPair<ParmVarDecl *, 1, bool> Param;
|
|
|
|
/// \brief The location where the default argument expression was used.
|
|
SourceLocation Loc;
|
|
|
|
CXXDefaultArgExpr(StmtClass SC, SourceLocation Loc, ParmVarDecl *param)
|
|
: Expr(SC,
|
|
param->hasUnparsedDefaultArg()
|
|
? param->getType().getNonReferenceType()
|
|
: param->getDefaultArg()->getType(),
|
|
param->getDefaultArg()->getValueKind(),
|
|
param->getDefaultArg()->getObjectKind(), false, false, false, false),
|
|
Param(param, false), Loc(Loc) { }
|
|
|
|
CXXDefaultArgExpr(StmtClass SC, SourceLocation Loc, ParmVarDecl *param,
|
|
Expr *SubExpr)
|
|
: Expr(SC, SubExpr->getType(),
|
|
SubExpr->getValueKind(), SubExpr->getObjectKind(),
|
|
false, false, false, false),
|
|
Param(param, true), Loc(Loc) {
|
|
*reinterpret_cast<Expr **>(this + 1) = SubExpr;
|
|
}
|
|
|
|
public:
|
|
CXXDefaultArgExpr(EmptyShell Empty) : Expr(CXXDefaultArgExprClass, Empty) {}
|
|
|
|
// \p Param is the parameter whose default argument is used by this
|
|
// expression.
|
|
static CXXDefaultArgExpr *Create(const ASTContext &C, SourceLocation Loc,
|
|
ParmVarDecl *Param) {
|
|
return new (C) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param);
|
|
}
|
|
|
|
// \p Param is the parameter whose default argument is used by this
|
|
// expression, and \p SubExpr is the expression that will actually be used.
|
|
static CXXDefaultArgExpr *Create(const ASTContext &C, SourceLocation Loc,
|
|
ParmVarDecl *Param, Expr *SubExpr);
|
|
|
|
// Retrieve the parameter that the argument was created from.
|
|
const ParmVarDecl *getParam() const { return Param.getPointer(); }
|
|
ParmVarDecl *getParam() { return Param.getPointer(); }
|
|
|
|
// Retrieve the actual argument to the function call.
|
|
const Expr *getExpr() const {
|
|
if (Param.getInt())
|
|
return *reinterpret_cast<Expr const * const*> (this + 1);
|
|
return getParam()->getDefaultArg();
|
|
}
|
|
Expr *getExpr() {
|
|
if (Param.getInt())
|
|
return *reinterpret_cast<Expr **> (this + 1);
|
|
return getParam()->getDefaultArg();
|
|
}
|
|
|
|
/// \brief Retrieve the location where this default argument was actually
|
|
/// used.
|
|
SourceLocation getUsedLocation() const { return Loc; }
|
|
|
|
/// Default argument expressions have no representation in the
|
|
/// source, so they have an empty source range.
|
|
SourceLocation getLocStart() const LLVM_READONLY { return SourceLocation(); }
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return SourceLocation(); }
|
|
|
|
SourceLocation getExprLoc() const LLVM_READONLY { return Loc; }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXDefaultArgExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() { return child_range(); }
|
|
|
|
friend class ASTStmtReader;
|
|
friend class ASTStmtWriter;
|
|
};
|
|
|
|
/// \brief A use of a default initializer in a constructor or in aggregate
|
|
/// initialization.
|
|
///
|
|
/// This wraps a use of a C++ default initializer (technically,
|
|
/// a brace-or-equal-initializer for a non-static data member) when it
|
|
/// is implicitly used in a mem-initializer-list in a constructor
|
|
/// (C++11 [class.base.init]p8) or in aggregate initialization
|
|
/// (C++1y [dcl.init.aggr]p7).
|
|
class CXXDefaultInitExpr : public Expr {
|
|
/// \brief The field whose default is being used.
|
|
FieldDecl *Field;
|
|
|
|
/// \brief The location where the default initializer expression was used.
|
|
SourceLocation Loc;
|
|
|
|
CXXDefaultInitExpr(const ASTContext &C, SourceLocation Loc, FieldDecl *Field,
|
|
QualType T);
|
|
|
|
CXXDefaultInitExpr(EmptyShell Empty) : Expr(CXXDefaultInitExprClass, Empty) {}
|
|
|
|
public:
|
|
/// \p Field is the non-static data member whose default initializer is used
|
|
/// by this expression.
|
|
static CXXDefaultInitExpr *Create(const ASTContext &C, SourceLocation Loc,
|
|
FieldDecl *Field) {
|
|
return new (C) CXXDefaultInitExpr(C, Loc, Field, Field->getType());
|
|
}
|
|
|
|
/// \brief Get the field whose initializer will be used.
|
|
FieldDecl *getField() { return Field; }
|
|
const FieldDecl *getField() const { return Field; }
|
|
|
|
/// \brief Get the initialization expression that will be used.
|
|
const Expr *getExpr() const {
|
|
assert(Field->getInClassInitializer() && "initializer hasn't been parsed");
|
|
return Field->getInClassInitializer();
|
|
}
|
|
Expr *getExpr() {
|
|
assert(Field->getInClassInitializer() && "initializer hasn't been parsed");
|
|
return Field->getInClassInitializer();
|
|
}
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return Loc; }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXDefaultInitExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() { return child_range(); }
|
|
|
|
friend class ASTReader;
|
|
friend class ASTStmtReader;
|
|
};
|
|
|
|
/// \brief Represents a C++ temporary.
|
|
class CXXTemporary {
|
|
/// \brief The destructor that needs to be called.
|
|
const CXXDestructorDecl *Destructor;
|
|
|
|
explicit CXXTemporary(const CXXDestructorDecl *destructor)
|
|
: Destructor(destructor) { }
|
|
|
|
public:
|
|
static CXXTemporary *Create(const ASTContext &C,
|
|
const CXXDestructorDecl *Destructor);
|
|
|
|
const CXXDestructorDecl *getDestructor() const { return Destructor; }
|
|
void setDestructor(const CXXDestructorDecl *Dtor) {
|
|
Destructor = Dtor;
|
|
}
|
|
};
|
|
|
|
/// \brief Represents binding an expression to a temporary.
|
|
///
|
|
/// This ensures the destructor is called for the temporary. It should only be
|
|
/// needed for non-POD, non-trivially destructable class types. For example:
|
|
///
|
|
/// \code
|
|
/// struct S {
|
|
/// S() { } // User defined constructor makes S non-POD.
|
|
/// ~S() { } // User defined destructor makes it non-trivial.
|
|
/// };
|
|
/// void test() {
|
|
/// const S &s_ref = S(); // Requires a CXXBindTemporaryExpr.
|
|
/// }
|
|
/// \endcode
|
|
class CXXBindTemporaryExpr : public Expr {
|
|
CXXTemporary *Temp;
|
|
|
|
Stmt *SubExpr;
|
|
|
|
CXXBindTemporaryExpr(CXXTemporary *temp, Expr* SubExpr)
|
|
: Expr(CXXBindTemporaryExprClass, SubExpr->getType(),
|
|
VK_RValue, OK_Ordinary, SubExpr->isTypeDependent(),
|
|
SubExpr->isValueDependent(),
|
|
SubExpr->isInstantiationDependent(),
|
|
SubExpr->containsUnexpandedParameterPack()),
|
|
Temp(temp), SubExpr(SubExpr) { }
|
|
|
|
public:
|
|
CXXBindTemporaryExpr(EmptyShell Empty)
|
|
: Expr(CXXBindTemporaryExprClass, Empty), Temp(nullptr), SubExpr(nullptr) {}
|
|
|
|
static CXXBindTemporaryExpr *Create(const ASTContext &C, CXXTemporary *Temp,
|
|
Expr* SubExpr);
|
|
|
|
CXXTemporary *getTemporary() { return Temp; }
|
|
const CXXTemporary *getTemporary() const { return Temp; }
|
|
void setTemporary(CXXTemporary *T) { Temp = T; }
|
|
|
|
const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
|
|
Expr *getSubExpr() { return cast<Expr>(SubExpr); }
|
|
void setSubExpr(Expr *E) { SubExpr = E; }
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY {
|
|
return SubExpr->getLocStart();
|
|
}
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return SubExpr->getLocEnd();}
|
|
|
|
// Implement isa/cast/dyncast/etc.
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXBindTemporaryExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() { return child_range(&SubExpr, &SubExpr + 1); }
|
|
};
|
|
|
|
/// \brief Represents a call to a C++ constructor.
|
|
class CXXConstructExpr : public Expr {
|
|
public:
|
|
enum ConstructionKind {
|
|
CK_Complete,
|
|
CK_NonVirtualBase,
|
|
CK_VirtualBase,
|
|
CK_Delegating
|
|
};
|
|
|
|
private:
|
|
CXXConstructorDecl *Constructor;
|
|
|
|
SourceLocation Loc;
|
|
SourceRange ParenOrBraceRange;
|
|
unsigned NumArgs : 16;
|
|
bool Elidable : 1;
|
|
bool HadMultipleCandidates : 1;
|
|
bool ListInitialization : 1;
|
|
bool StdInitListInitialization : 1;
|
|
bool ZeroInitialization : 1;
|
|
unsigned ConstructKind : 2;
|
|
Stmt **Args;
|
|
|
|
protected:
|
|
CXXConstructExpr(const ASTContext &C, StmtClass SC, QualType T,
|
|
SourceLocation Loc,
|
|
CXXConstructorDecl *d, bool elidable,
|
|
ArrayRef<Expr *> Args,
|
|
bool HadMultipleCandidates,
|
|
bool ListInitialization,
|
|
bool StdInitListInitialization,
|
|
bool ZeroInitialization,
|
|
ConstructionKind ConstructKind,
|
|
SourceRange ParenOrBraceRange);
|
|
|
|
/// \brief Construct an empty C++ construction expression.
|
|
CXXConstructExpr(StmtClass SC, EmptyShell Empty)
|
|
: Expr(SC, Empty), Constructor(nullptr), NumArgs(0), Elidable(false),
|
|
HadMultipleCandidates(false), ListInitialization(false),
|
|
ZeroInitialization(false), ConstructKind(0), Args(nullptr)
|
|
{ }
|
|
|
|
public:
|
|
/// \brief Construct an empty C++ construction expression.
|
|
explicit CXXConstructExpr(EmptyShell Empty)
|
|
: Expr(CXXConstructExprClass, Empty), Constructor(nullptr),
|
|
NumArgs(0), Elidable(false), HadMultipleCandidates(false),
|
|
ListInitialization(false), ZeroInitialization(false),
|
|
ConstructKind(0), Args(nullptr)
|
|
{ }
|
|
|
|
static CXXConstructExpr *Create(const ASTContext &C, QualType T,
|
|
SourceLocation Loc,
|
|
CXXConstructorDecl *D, bool Elidable,
|
|
ArrayRef<Expr *> Args,
|
|
bool HadMultipleCandidates,
|
|
bool ListInitialization,
|
|
bool StdInitListInitialization,
|
|
bool ZeroInitialization,
|
|
ConstructionKind ConstructKind,
|
|
SourceRange ParenOrBraceRange);
|
|
|
|
CXXConstructorDecl *getConstructor() const { return Constructor; }
|
|
void setConstructor(CXXConstructorDecl *C) { Constructor = C; }
|
|
|
|
SourceLocation getLocation() const { return Loc; }
|
|
void setLocation(SourceLocation Loc) { this->Loc = Loc; }
|
|
|
|
/// \brief Whether this construction is elidable.
|
|
bool isElidable() const { return Elidable; }
|
|
void setElidable(bool E) { Elidable = E; }
|
|
|
|
/// \brief Whether the referred constructor was resolved from
|
|
/// an overloaded set having size greater than 1.
|
|
bool hadMultipleCandidates() const { return HadMultipleCandidates; }
|
|
void setHadMultipleCandidates(bool V) { HadMultipleCandidates = V; }
|
|
|
|
/// \brief Whether this constructor call was written as list-initialization.
|
|
bool isListInitialization() const { return ListInitialization; }
|
|
void setListInitialization(bool V) { ListInitialization = V; }
|
|
|
|
/// \brief Whether this constructor call was written as list-initialization,
|
|
/// but was interpreted as forming a std::initializer_list<T> from the list
|
|
/// and passing that as a single constructor argument.
|
|
/// See C++11 [over.match.list]p1 bullet 1.
|
|
bool isStdInitListInitialization() const { return StdInitListInitialization; }
|
|
void setStdInitListInitialization(bool V) { StdInitListInitialization = V; }
|
|
|
|
/// \brief Whether this construction first requires
|
|
/// zero-initialization before the initializer is called.
|
|
bool requiresZeroInitialization() const { return ZeroInitialization; }
|
|
void setRequiresZeroInitialization(bool ZeroInit) {
|
|
ZeroInitialization = ZeroInit;
|
|
}
|
|
|
|
/// \brief Determine whether this constructor is actually constructing
|
|
/// a base class (rather than a complete object).
|
|
ConstructionKind getConstructionKind() const {
|
|
return (ConstructionKind)ConstructKind;
|
|
}
|
|
void setConstructionKind(ConstructionKind CK) {
|
|
ConstructKind = CK;
|
|
}
|
|
|
|
typedef ExprIterator arg_iterator;
|
|
typedef ConstExprIterator const_arg_iterator;
|
|
typedef llvm::iterator_range<arg_iterator> arg_range;
|
|
typedef llvm::iterator_range<const_arg_iterator> arg_const_range;
|
|
|
|
arg_range arguments() { return arg_range(arg_begin(), arg_end()); }
|
|
arg_const_range arguments() const {
|
|
return arg_const_range(arg_begin(), arg_end());
|
|
}
|
|
|
|
arg_iterator arg_begin() { return Args; }
|
|
arg_iterator arg_end() { return Args + NumArgs; }
|
|
const_arg_iterator arg_begin() const { return Args; }
|
|
const_arg_iterator arg_end() const { return Args + NumArgs; }
|
|
|
|
Expr **getArgs() { return reinterpret_cast<Expr **>(Args); }
|
|
const Expr *const *getArgs() const {
|
|
return const_cast<CXXConstructExpr *>(this)->getArgs();
|
|
}
|
|
unsigned getNumArgs() const { return NumArgs; }
|
|
|
|
/// \brief Return the specified argument.
|
|
Expr *getArg(unsigned Arg) {
|
|
assert(Arg < NumArgs && "Arg access out of range!");
|
|
return cast<Expr>(Args[Arg]);
|
|
}
|
|
const Expr *getArg(unsigned Arg) const {
|
|
assert(Arg < NumArgs && "Arg access out of range!");
|
|
return cast<Expr>(Args[Arg]);
|
|
}
|
|
|
|
/// \brief Set the specified argument.
|
|
void setArg(unsigned Arg, Expr *ArgExpr) {
|
|
assert(Arg < NumArgs && "Arg access out of range!");
|
|
Args[Arg] = ArgExpr;
|
|
}
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY;
|
|
SourceLocation getLocEnd() const LLVM_READONLY;
|
|
SourceRange getParenOrBraceRange() const { return ParenOrBraceRange; }
|
|
void setParenOrBraceRange(SourceRange Range) { ParenOrBraceRange = Range; }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXConstructExprClass ||
|
|
T->getStmtClass() == CXXTemporaryObjectExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() {
|
|
return child_range(&Args[0], &Args[0]+NumArgs);
|
|
}
|
|
|
|
friend class ASTStmtReader;
|
|
};
|
|
|
|
/// \brief Represents an explicit C++ type conversion that uses "functional"
|
|
/// notation (C++ [expr.type.conv]).
|
|
///
|
|
/// Example:
|
|
/// \code
|
|
/// x = int(0.5);
|
|
/// \endcode
|
|
class CXXFunctionalCastExpr : public ExplicitCastExpr {
|
|
SourceLocation LParenLoc;
|
|
SourceLocation RParenLoc;
|
|
|
|
CXXFunctionalCastExpr(QualType ty, ExprValueKind VK,
|
|
TypeSourceInfo *writtenTy,
|
|
CastKind kind, Expr *castExpr, unsigned pathSize,
|
|
SourceLocation lParenLoc, SourceLocation rParenLoc)
|
|
: ExplicitCastExpr(CXXFunctionalCastExprClass, ty, VK, kind,
|
|
castExpr, pathSize, writtenTy),
|
|
LParenLoc(lParenLoc), RParenLoc(rParenLoc) {}
|
|
|
|
explicit CXXFunctionalCastExpr(EmptyShell Shell, unsigned PathSize)
|
|
: ExplicitCastExpr(CXXFunctionalCastExprClass, Shell, PathSize) { }
|
|
|
|
public:
|
|
static CXXFunctionalCastExpr *Create(const ASTContext &Context, QualType T,
|
|
ExprValueKind VK,
|
|
TypeSourceInfo *Written,
|
|
CastKind Kind, Expr *Op,
|
|
const CXXCastPath *Path,
|
|
SourceLocation LPLoc,
|
|
SourceLocation RPLoc);
|
|
static CXXFunctionalCastExpr *CreateEmpty(const ASTContext &Context,
|
|
unsigned PathSize);
|
|
|
|
SourceLocation getLParenLoc() const { return LParenLoc; }
|
|
void setLParenLoc(SourceLocation L) { LParenLoc = L; }
|
|
SourceLocation getRParenLoc() const { return RParenLoc; }
|
|
void setRParenLoc(SourceLocation L) { RParenLoc = L; }
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY;
|
|
SourceLocation getLocEnd() const LLVM_READONLY;
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXFunctionalCastExprClass;
|
|
}
|
|
};
|
|
|
|
/// @brief Represents a C++ functional cast expression that builds a
|
|
/// temporary object.
|
|
///
|
|
/// This expression type represents a C++ "functional" cast
|
|
/// (C++[expr.type.conv]) with N != 1 arguments that invokes a
|
|
/// constructor to build a temporary object. With N == 1 arguments the
|
|
/// functional cast expression will be represented by CXXFunctionalCastExpr.
|
|
/// Example:
|
|
/// \code
|
|
/// struct X { X(int, float); }
|
|
///
|
|
/// X create_X() {
|
|
/// return X(1, 3.14f); // creates a CXXTemporaryObjectExpr
|
|
/// };
|
|
/// \endcode
|
|
class CXXTemporaryObjectExpr : public CXXConstructExpr {
|
|
TypeSourceInfo *Type;
|
|
|
|
public:
|
|
CXXTemporaryObjectExpr(const ASTContext &C, CXXConstructorDecl *Cons,
|
|
TypeSourceInfo *Type,
|
|
ArrayRef<Expr *> Args,
|
|
SourceRange ParenOrBraceRange,
|
|
bool HadMultipleCandidates,
|
|
bool ListInitialization,
|
|
bool StdInitListInitialization,
|
|
bool ZeroInitialization);
|
|
explicit CXXTemporaryObjectExpr(EmptyShell Empty)
|
|
: CXXConstructExpr(CXXTemporaryObjectExprClass, Empty), Type() { }
|
|
|
|
TypeSourceInfo *getTypeSourceInfo() const { return Type; }
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY;
|
|
SourceLocation getLocEnd() const LLVM_READONLY;
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXTemporaryObjectExprClass;
|
|
}
|
|
|
|
friend class ASTStmtReader;
|
|
};
|
|
|
|
/// \brief A C++ lambda expression, which produces a function object
|
|
/// (of unspecified type) that can be invoked later.
|
|
///
|
|
/// Example:
|
|
/// \code
|
|
/// void low_pass_filter(std::vector<double> &values, double cutoff) {
|
|
/// values.erase(std::remove_if(values.begin(), values.end(),
|
|
/// [=](double value) { return value > cutoff; });
|
|
/// }
|
|
/// \endcode
|
|
///
|
|
/// C++11 lambda expressions can capture local variables, either by copying
|
|
/// the values of those local variables at the time the function
|
|
/// object is constructed (not when it is called!) or by holding a
|
|
/// reference to the local variable. These captures can occur either
|
|
/// implicitly or can be written explicitly between the square
|
|
/// brackets ([...]) that start the lambda expression.
|
|
///
|
|
/// C++1y introduces a new form of "capture" called an init-capture that
|
|
/// includes an initializing expression (rather than capturing a variable),
|
|
/// and which can never occur implicitly.
|
|
class LambdaExpr : public Expr {
|
|
/// \brief The source range that covers the lambda introducer ([...]).
|
|
SourceRange IntroducerRange;
|
|
|
|
/// \brief The source location of this lambda's capture-default ('=' or '&').
|
|
SourceLocation CaptureDefaultLoc;
|
|
|
|
/// \brief The number of captures.
|
|
unsigned NumCaptures : 16;
|
|
|
|
/// \brief The default capture kind, which is a value of type
|
|
/// LambdaCaptureDefault.
|
|
unsigned CaptureDefault : 2;
|
|
|
|
/// \brief Whether this lambda had an explicit parameter list vs. an
|
|
/// implicit (and empty) parameter list.
|
|
unsigned ExplicitParams : 1;
|
|
|
|
/// \brief Whether this lambda had the result type explicitly specified.
|
|
unsigned ExplicitResultType : 1;
|
|
|
|
/// \brief Whether there are any array index variables stored at the end of
|
|
/// this lambda expression.
|
|
unsigned HasArrayIndexVars : 1;
|
|
|
|
/// \brief The location of the closing brace ('}') that completes
|
|
/// the lambda.
|
|
///
|
|
/// The location of the brace is also available by looking up the
|
|
/// function call operator in the lambda class. However, it is
|
|
/// stored here to improve the performance of getSourceRange(), and
|
|
/// to avoid having to deserialize the function call operator from a
|
|
/// module file just to determine the source range.
|
|
SourceLocation ClosingBrace;
|
|
|
|
// Note: The capture initializers are stored directly after the lambda
|
|
// expression, along with the index variables used to initialize by-copy
|
|
// array captures.
|
|
|
|
typedef LambdaCapture Capture;
|
|
|
|
/// \brief Construct a lambda expression.
|
|
LambdaExpr(QualType T, SourceRange IntroducerRange,
|
|
LambdaCaptureDefault CaptureDefault,
|
|
SourceLocation CaptureDefaultLoc,
|
|
ArrayRef<Capture> Captures,
|
|
bool ExplicitParams,
|
|
bool ExplicitResultType,
|
|
ArrayRef<Expr *> CaptureInits,
|
|
ArrayRef<VarDecl *> ArrayIndexVars,
|
|
ArrayRef<unsigned> ArrayIndexStarts,
|
|
SourceLocation ClosingBrace,
|
|
bool ContainsUnexpandedParameterPack);
|
|
|
|
/// \brief Construct an empty lambda expression.
|
|
LambdaExpr(EmptyShell Empty, unsigned NumCaptures, bool HasArrayIndexVars)
|
|
: Expr(LambdaExprClass, Empty),
|
|
NumCaptures(NumCaptures), CaptureDefault(LCD_None), ExplicitParams(false),
|
|
ExplicitResultType(false), HasArrayIndexVars(true) {
|
|
getStoredStmts()[NumCaptures] = nullptr;
|
|
}
|
|
|
|
Stmt **getStoredStmts() const {
|
|
return reinterpret_cast<Stmt **>(const_cast<LambdaExpr *>(this) + 1);
|
|
}
|
|
|
|
/// \brief Retrieve the mapping from captures to the first array index
|
|
/// variable.
|
|
unsigned *getArrayIndexStarts() const {
|
|
return reinterpret_cast<unsigned *>(getStoredStmts() + NumCaptures + 1);
|
|
}
|
|
|
|
/// \brief Retrieve the complete set of array-index variables.
|
|
VarDecl **getArrayIndexVars() const {
|
|
unsigned ArrayIndexSize = llvm::RoundUpToAlignment(
|
|
sizeof(unsigned) * (NumCaptures + 1), llvm::alignOf<VarDecl *>());
|
|
return reinterpret_cast<VarDecl **>(
|
|
reinterpret_cast<char *>(getArrayIndexStarts()) + ArrayIndexSize);
|
|
}
|
|
|
|
public:
|
|
/// \brief Construct a new lambda expression.
|
|
static LambdaExpr *Create(const ASTContext &C,
|
|
CXXRecordDecl *Class,
|
|
SourceRange IntroducerRange,
|
|
LambdaCaptureDefault CaptureDefault,
|
|
SourceLocation CaptureDefaultLoc,
|
|
ArrayRef<Capture> Captures,
|
|
bool ExplicitParams,
|
|
bool ExplicitResultType,
|
|
ArrayRef<Expr *> CaptureInits,
|
|
ArrayRef<VarDecl *> ArrayIndexVars,
|
|
ArrayRef<unsigned> ArrayIndexStarts,
|
|
SourceLocation ClosingBrace,
|
|
bool ContainsUnexpandedParameterPack);
|
|
|
|
/// \brief Construct a new lambda expression that will be deserialized from
|
|
/// an external source.
|
|
static LambdaExpr *CreateDeserialized(const ASTContext &C,
|
|
unsigned NumCaptures,
|
|
unsigned NumArrayIndexVars);
|
|
|
|
/// \brief Determine the default capture kind for this lambda.
|
|
LambdaCaptureDefault getCaptureDefault() const {
|
|
return static_cast<LambdaCaptureDefault>(CaptureDefault);
|
|
}
|
|
|
|
/// \brief Retrieve the location of this lambda's capture-default, if any.
|
|
SourceLocation getCaptureDefaultLoc() const {
|
|
return CaptureDefaultLoc;
|
|
}
|
|
|
|
/// \brief Determine whether one of this lambda's captures is an init-capture.
|
|
bool isInitCapture(const LambdaCapture *Capture) const;
|
|
|
|
/// \brief An iterator that walks over the captures of the lambda,
|
|
/// both implicit and explicit.
|
|
typedef const Capture *capture_iterator;
|
|
|
|
/// \brief An iterator over a range of lambda captures.
|
|
typedef llvm::iterator_range<capture_iterator> capture_range;
|
|
|
|
/// \brief Retrieve this lambda's captures.
|
|
capture_range captures() const;
|
|
|
|
/// \brief Retrieve an iterator pointing to the first lambda capture.
|
|
capture_iterator capture_begin() const;
|
|
|
|
/// \brief Retrieve an iterator pointing past the end of the
|
|
/// sequence of lambda captures.
|
|
capture_iterator capture_end() const;
|
|
|
|
/// \brief Determine the number of captures in this lambda.
|
|
unsigned capture_size() const { return NumCaptures; }
|
|
|
|
/// \brief Retrieve this lambda's explicit captures.
|
|
capture_range explicit_captures() const;
|
|
|
|
/// \brief Retrieve an iterator pointing to the first explicit
|
|
/// lambda capture.
|
|
capture_iterator explicit_capture_begin() const;
|
|
|
|
/// \brief Retrieve an iterator pointing past the end of the sequence of
|
|
/// explicit lambda captures.
|
|
capture_iterator explicit_capture_end() const;
|
|
|
|
/// \brief Retrieve this lambda's implicit captures.
|
|
capture_range implicit_captures() const;
|
|
|
|
/// \brief Retrieve an iterator pointing to the first implicit
|
|
/// lambda capture.
|
|
capture_iterator implicit_capture_begin() const;
|
|
|
|
/// \brief Retrieve an iterator pointing past the end of the sequence of
|
|
/// implicit lambda captures.
|
|
capture_iterator implicit_capture_end() const;
|
|
|
|
/// \brief Iterator that walks over the capture initialization
|
|
/// arguments.
|
|
typedef Expr **capture_init_iterator;
|
|
|
|
/// \brief Retrieve the initialization expressions for this lambda's captures.
|
|
llvm::iterator_range<capture_init_iterator> capture_inits() const {
|
|
return llvm::iterator_range<capture_init_iterator>(capture_init_begin(),
|
|
capture_init_end());
|
|
}
|
|
|
|
/// \brief Retrieve the first initialization argument for this
|
|
/// lambda expression (which initializes the first capture field).
|
|
capture_init_iterator capture_init_begin() const {
|
|
return reinterpret_cast<Expr **>(getStoredStmts());
|
|
}
|
|
|
|
/// \brief Retrieve the iterator pointing one past the last
|
|
/// initialization argument for this lambda expression.
|
|
capture_init_iterator capture_init_end() const {
|
|
return capture_init_begin() + NumCaptures;
|
|
}
|
|
|
|
/// \brief Retrieve the set of index variables used in the capture
|
|
/// initializer of an array captured by copy.
|
|
///
|
|
/// \param Iter The iterator that points at the capture initializer for
|
|
/// which we are extracting the corresponding index variables.
|
|
ArrayRef<VarDecl *> getCaptureInitIndexVars(capture_init_iterator Iter) const;
|
|
|
|
/// \brief Retrieve the source range covering the lambda introducer,
|
|
/// which contains the explicit capture list surrounded by square
|
|
/// brackets ([...]).
|
|
SourceRange getIntroducerRange() const { return IntroducerRange; }
|
|
|
|
/// \brief Retrieve the class that corresponds to the lambda.
|
|
///
|
|
/// This is the "closure type" (C++1y [expr.prim.lambda]), and stores the
|
|
/// captures in its fields and provides the various operations permitted
|
|
/// on a lambda (copying, calling).
|
|
CXXRecordDecl *getLambdaClass() const;
|
|
|
|
/// \brief Retrieve the function call operator associated with this
|
|
/// lambda expression.
|
|
CXXMethodDecl *getCallOperator() const;
|
|
|
|
/// \brief If this is a generic lambda expression, retrieve the template
|
|
/// parameter list associated with it, or else return null.
|
|
TemplateParameterList *getTemplateParameterList() const;
|
|
|
|
/// \brief Whether this is a generic lambda.
|
|
bool isGenericLambda() const { return getTemplateParameterList(); }
|
|
|
|
/// \brief Retrieve the body of the lambda.
|
|
CompoundStmt *getBody() const;
|
|
|
|
/// \brief Determine whether the lambda is mutable, meaning that any
|
|
/// captures values can be modified.
|
|
bool isMutable() const;
|
|
|
|
/// \brief Determine whether this lambda has an explicit parameter
|
|
/// list vs. an implicit (empty) parameter list.
|
|
bool hasExplicitParameters() const { return ExplicitParams; }
|
|
|
|
/// \brief Whether this lambda had its result type explicitly specified.
|
|
bool hasExplicitResultType() const { return ExplicitResultType; }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == LambdaExprClass;
|
|
}
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY {
|
|
return IntroducerRange.getBegin();
|
|
}
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return ClosingBrace; }
|
|
|
|
child_range children() {
|
|
return child_range(getStoredStmts(), getStoredStmts() + NumCaptures + 1);
|
|
}
|
|
|
|
friend class ASTStmtReader;
|
|
friend class ASTStmtWriter;
|
|
};
|
|
|
|
/// An expression "T()" which creates a value-initialized rvalue of type
|
|
/// T, which is a non-class type. See (C++98 [5.2.3p2]).
|
|
class CXXScalarValueInitExpr : public Expr {
|
|
SourceLocation RParenLoc;
|
|
TypeSourceInfo *TypeInfo;
|
|
|
|
friend class ASTStmtReader;
|
|
|
|
public:
|
|
/// \brief Create an explicitly-written scalar-value initialization
|
|
/// expression.
|
|
CXXScalarValueInitExpr(QualType Type, TypeSourceInfo *TypeInfo,
|
|
SourceLocation rParenLoc)
|
|
: Expr(CXXScalarValueInitExprClass, Type, VK_RValue, OK_Ordinary,
|
|
false, false, Type->isInstantiationDependentType(),
|
|
Type->containsUnexpandedParameterPack()),
|
|
RParenLoc(rParenLoc), TypeInfo(TypeInfo) {}
|
|
|
|
explicit CXXScalarValueInitExpr(EmptyShell Shell)
|
|
: Expr(CXXScalarValueInitExprClass, Shell) { }
|
|
|
|
TypeSourceInfo *getTypeSourceInfo() const {
|
|
return TypeInfo;
|
|
}
|
|
|
|
SourceLocation getRParenLoc() const { return RParenLoc; }
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY;
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return RParenLoc; }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXScalarValueInitExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() { return child_range(); }
|
|
};
|
|
|
|
/// \brief Represents a new-expression for memory allocation and constructor
|
|
/// calls, e.g: "new CXXNewExpr(foo)".
|
|
class CXXNewExpr : public Expr {
|
|
/// Contains an optional array size expression, an optional initialization
|
|
/// expression, and any number of optional placement arguments, in that order.
|
|
Stmt **SubExprs;
|
|
/// \brief Points to the allocation function used.
|
|
FunctionDecl *OperatorNew;
|
|
/// \brief Points to the deallocation function used in case of error. May be
|
|
/// null.
|
|
FunctionDecl *OperatorDelete;
|
|
|
|
/// \brief The allocated type-source information, as written in the source.
|
|
TypeSourceInfo *AllocatedTypeInfo;
|
|
|
|
/// \brief If the allocated type was expressed as a parenthesized type-id,
|
|
/// the source range covering the parenthesized type-id.
|
|
SourceRange TypeIdParens;
|
|
|
|
/// \brief Range of the entire new expression.
|
|
SourceRange Range;
|
|
|
|
/// \brief Source-range of a paren-delimited initializer.
|
|
SourceRange DirectInitRange;
|
|
|
|
/// Was the usage ::new, i.e. is the global new to be used?
|
|
bool GlobalNew : 1;
|
|
/// Do we allocate an array? If so, the first SubExpr is the size expression.
|
|
bool Array : 1;
|
|
/// If this is an array allocation, does the usual deallocation
|
|
/// function for the allocated type want to know the allocated size?
|
|
bool UsualArrayDeleteWantsSize : 1;
|
|
/// The number of placement new arguments.
|
|
unsigned NumPlacementArgs : 13;
|
|
/// What kind of initializer do we have? Could be none, parens, or braces.
|
|
/// In storage, we distinguish between "none, and no initializer expr", and
|
|
/// "none, but an implicit initializer expr".
|
|
unsigned StoredInitializationStyle : 2;
|
|
|
|
friend class ASTStmtReader;
|
|
friend class ASTStmtWriter;
|
|
public:
|
|
enum InitializationStyle {
|
|
NoInit, ///< New-expression has no initializer as written.
|
|
CallInit, ///< New-expression has a C++98 paren-delimited initializer.
|
|
ListInit ///< New-expression has a C++11 list-initializer.
|
|
};
|
|
|
|
CXXNewExpr(const ASTContext &C, bool globalNew, FunctionDecl *operatorNew,
|
|
FunctionDecl *operatorDelete, bool usualArrayDeleteWantsSize,
|
|
ArrayRef<Expr*> placementArgs,
|
|
SourceRange typeIdParens, Expr *arraySize,
|
|
InitializationStyle initializationStyle, Expr *initializer,
|
|
QualType ty, TypeSourceInfo *AllocatedTypeInfo,
|
|
SourceRange Range, SourceRange directInitRange);
|
|
explicit CXXNewExpr(EmptyShell Shell)
|
|
: Expr(CXXNewExprClass, Shell), SubExprs(nullptr) { }
|
|
|
|
void AllocateArgsArray(const ASTContext &C, bool isArray,
|
|
unsigned numPlaceArgs, bool hasInitializer);
|
|
|
|
QualType getAllocatedType() const {
|
|
assert(getType()->isPointerType());
|
|
return getType()->getAs<PointerType>()->getPointeeType();
|
|
}
|
|
|
|
TypeSourceInfo *getAllocatedTypeSourceInfo() const {
|
|
return AllocatedTypeInfo;
|
|
}
|
|
|
|
/// \brief True if the allocation result needs to be null-checked.
|
|
///
|
|
/// C++11 [expr.new]p13:
|
|
/// If the allocation function returns null, initialization shall
|
|
/// not be done, the deallocation function shall not be called,
|
|
/// and the value of the new-expression shall be null.
|
|
///
|
|
/// C++ DR1748:
|
|
/// If the allocation function is a reserved placement allocation
|
|
/// function that returns null, the behavior is undefined.
|
|
///
|
|
/// An allocation function is not allowed to return null unless it
|
|
/// has a non-throwing exception-specification. The '03 rule is
|
|
/// identical except that the definition of a non-throwing
|
|
/// exception specification is just "is it throw()?".
|
|
bool shouldNullCheckAllocation(const ASTContext &Ctx) const;
|
|
|
|
FunctionDecl *getOperatorNew() const { return OperatorNew; }
|
|
void setOperatorNew(FunctionDecl *D) { OperatorNew = D; }
|
|
FunctionDecl *getOperatorDelete() const { return OperatorDelete; }
|
|
void setOperatorDelete(FunctionDecl *D) { OperatorDelete = D; }
|
|
|
|
bool isArray() const { return Array; }
|
|
Expr *getArraySize() {
|
|
return Array ? cast<Expr>(SubExprs[0]) : nullptr;
|
|
}
|
|
const Expr *getArraySize() const {
|
|
return Array ? cast<Expr>(SubExprs[0]) : nullptr;
|
|
}
|
|
|
|
unsigned getNumPlacementArgs() const { return NumPlacementArgs; }
|
|
Expr **getPlacementArgs() {
|
|
return reinterpret_cast<Expr **>(SubExprs + Array + hasInitializer());
|
|
}
|
|
|
|
Expr *getPlacementArg(unsigned i) {
|
|
assert(i < NumPlacementArgs && "Index out of range");
|
|
return getPlacementArgs()[i];
|
|
}
|
|
const Expr *getPlacementArg(unsigned i) const {
|
|
assert(i < NumPlacementArgs && "Index out of range");
|
|
return const_cast<CXXNewExpr*>(this)->getPlacementArg(i);
|
|
}
|
|
|
|
bool isParenTypeId() const { return TypeIdParens.isValid(); }
|
|
SourceRange getTypeIdParens() const { return TypeIdParens; }
|
|
|
|
bool isGlobalNew() const { return GlobalNew; }
|
|
|
|
/// \brief Whether this new-expression has any initializer at all.
|
|
bool hasInitializer() const { return StoredInitializationStyle > 0; }
|
|
|
|
/// \brief The kind of initializer this new-expression has.
|
|
InitializationStyle getInitializationStyle() const {
|
|
if (StoredInitializationStyle == 0)
|
|
return NoInit;
|
|
return static_cast<InitializationStyle>(StoredInitializationStyle-1);
|
|
}
|
|
|
|
/// \brief The initializer of this new-expression.
|
|
Expr *getInitializer() {
|
|
return hasInitializer() ? cast<Expr>(SubExprs[Array]) : nullptr;
|
|
}
|
|
const Expr *getInitializer() const {
|
|
return hasInitializer() ? cast<Expr>(SubExprs[Array]) : nullptr;
|
|
}
|
|
|
|
/// \brief Returns the CXXConstructExpr from this new-expression, or null.
|
|
const CXXConstructExpr* getConstructExpr() const {
|
|
return dyn_cast_or_null<CXXConstructExpr>(getInitializer());
|
|
}
|
|
|
|
/// Answers whether the usual array deallocation function for the
|
|
/// allocated type expects the size of the allocation as a
|
|
/// parameter.
|
|
bool doesUsualArrayDeleteWantSize() const {
|
|
return UsualArrayDeleteWantsSize;
|
|
}
|
|
|
|
typedef ExprIterator arg_iterator;
|
|
typedef ConstExprIterator const_arg_iterator;
|
|
|
|
arg_iterator placement_arg_begin() {
|
|
return SubExprs + Array + hasInitializer();
|
|
}
|
|
arg_iterator placement_arg_end() {
|
|
return SubExprs + Array + hasInitializer() + getNumPlacementArgs();
|
|
}
|
|
const_arg_iterator placement_arg_begin() const {
|
|
return SubExprs + Array + hasInitializer();
|
|
}
|
|
const_arg_iterator placement_arg_end() const {
|
|
return SubExprs + Array + hasInitializer() + getNumPlacementArgs();
|
|
}
|
|
|
|
typedef Stmt **raw_arg_iterator;
|
|
raw_arg_iterator raw_arg_begin() { return SubExprs; }
|
|
raw_arg_iterator raw_arg_end() {
|
|
return SubExprs + Array + hasInitializer() + getNumPlacementArgs();
|
|
}
|
|
const_arg_iterator raw_arg_begin() const { return SubExprs; }
|
|
const_arg_iterator raw_arg_end() const {
|
|
return SubExprs + Array + hasInitializer() + getNumPlacementArgs();
|
|
}
|
|
|
|
SourceLocation getStartLoc() const { return Range.getBegin(); }
|
|
SourceLocation getEndLoc() const { return Range.getEnd(); }
|
|
|
|
SourceRange getDirectInitRange() const { return DirectInitRange; }
|
|
|
|
SourceRange getSourceRange() const LLVM_READONLY {
|
|
return Range;
|
|
}
|
|
SourceLocation getLocStart() const LLVM_READONLY { return getStartLoc(); }
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return getEndLoc(); }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXNewExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() {
|
|
return child_range(raw_arg_begin(), raw_arg_end());
|
|
}
|
|
};
|
|
|
|
/// \brief Represents a \c delete expression for memory deallocation and
|
|
/// destructor calls, e.g. "delete[] pArray".
|
|
class CXXDeleteExpr : public Expr {
|
|
/// Points to the operator delete overload that is used. Could be a member.
|
|
FunctionDecl *OperatorDelete;
|
|
/// The pointer expression to be deleted.
|
|
Stmt *Argument;
|
|
/// Location of the expression.
|
|
SourceLocation Loc;
|
|
/// Is this a forced global delete, i.e. "::delete"?
|
|
bool GlobalDelete : 1;
|
|
/// Is this the array form of delete, i.e. "delete[]"?
|
|
bool ArrayForm : 1;
|
|
/// ArrayFormAsWritten can be different from ArrayForm if 'delete' is applied
|
|
/// to pointer-to-array type (ArrayFormAsWritten will be false while ArrayForm
|
|
/// will be true).
|
|
bool ArrayFormAsWritten : 1;
|
|
/// Does the usual deallocation function for the element type require
|
|
/// a size_t argument?
|
|
bool UsualArrayDeleteWantsSize : 1;
|
|
public:
|
|
CXXDeleteExpr(QualType ty, bool globalDelete, bool arrayForm,
|
|
bool arrayFormAsWritten, bool usualArrayDeleteWantsSize,
|
|
FunctionDecl *operatorDelete, Expr *arg, SourceLocation loc)
|
|
: Expr(CXXDeleteExprClass, ty, VK_RValue, OK_Ordinary, false, false,
|
|
arg->isInstantiationDependent(),
|
|
arg->containsUnexpandedParameterPack()),
|
|
OperatorDelete(operatorDelete), Argument(arg), Loc(loc),
|
|
GlobalDelete(globalDelete),
|
|
ArrayForm(arrayForm), ArrayFormAsWritten(arrayFormAsWritten),
|
|
UsualArrayDeleteWantsSize(usualArrayDeleteWantsSize) { }
|
|
explicit CXXDeleteExpr(EmptyShell Shell)
|
|
: Expr(CXXDeleteExprClass, Shell), OperatorDelete(nullptr),
|
|
Argument(nullptr) {}
|
|
|
|
bool isGlobalDelete() const { return GlobalDelete; }
|
|
bool isArrayForm() const { return ArrayForm; }
|
|
bool isArrayFormAsWritten() const { return ArrayFormAsWritten; }
|
|
|
|
/// Answers whether the usual array deallocation function for the
|
|
/// allocated type expects the size of the allocation as a
|
|
/// parameter. This can be true even if the actual deallocation
|
|
/// function that we're using doesn't want a size.
|
|
bool doesUsualArrayDeleteWantSize() const {
|
|
return UsualArrayDeleteWantsSize;
|
|
}
|
|
|
|
FunctionDecl *getOperatorDelete() const { return OperatorDelete; }
|
|
|
|
Expr *getArgument() { return cast<Expr>(Argument); }
|
|
const Expr *getArgument() const { return cast<Expr>(Argument); }
|
|
|
|
/// \brief Retrieve the type being destroyed.
|
|
///
|
|
/// If the type being destroyed is a dependent type which may or may not
|
|
/// be a pointer, return an invalid type.
|
|
QualType getDestroyedType() const;
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
|
|
SourceLocation getLocEnd() const LLVM_READONLY {return Argument->getLocEnd();}
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXDeleteExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() { return child_range(&Argument, &Argument+1); }
|
|
|
|
friend class ASTStmtReader;
|
|
};
|
|
|
|
/// \brief Stores the type being destroyed by a pseudo-destructor expression.
|
|
class PseudoDestructorTypeStorage {
|
|
/// \brief Either the type source information or the name of the type, if
|
|
/// it couldn't be resolved due to type-dependence.
|
|
llvm::PointerUnion<TypeSourceInfo *, IdentifierInfo *> Type;
|
|
|
|
/// \brief The starting source location of the pseudo-destructor type.
|
|
SourceLocation Location;
|
|
|
|
public:
|
|
PseudoDestructorTypeStorage() { }
|
|
|
|
PseudoDestructorTypeStorage(IdentifierInfo *II, SourceLocation Loc)
|
|
: Type(II), Location(Loc) { }
|
|
|
|
PseudoDestructorTypeStorage(TypeSourceInfo *Info);
|
|
|
|
TypeSourceInfo *getTypeSourceInfo() const {
|
|
return Type.dyn_cast<TypeSourceInfo *>();
|
|
}
|
|
|
|
IdentifierInfo *getIdentifier() const {
|
|
return Type.dyn_cast<IdentifierInfo *>();
|
|
}
|
|
|
|
SourceLocation getLocation() const { return Location; }
|
|
};
|
|
|
|
/// \brief Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
|
|
///
|
|
/// A pseudo-destructor is an expression that looks like a member access to a
|
|
/// destructor of a scalar type, except that scalar types don't have
|
|
/// destructors. For example:
|
|
///
|
|
/// \code
|
|
/// typedef int T;
|
|
/// void f(int *p) {
|
|
/// p->T::~T();
|
|
/// }
|
|
/// \endcode
|
|
///
|
|
/// Pseudo-destructors typically occur when instantiating templates such as:
|
|
///
|
|
/// \code
|
|
/// template<typename T>
|
|
/// void destroy(T* ptr) {
|
|
/// ptr->T::~T();
|
|
/// }
|
|
/// \endcode
|
|
///
|
|
/// for scalar types. A pseudo-destructor expression has no run-time semantics
|
|
/// beyond evaluating the base expression.
|
|
class CXXPseudoDestructorExpr : public Expr {
|
|
/// \brief The base expression (that is being destroyed).
|
|
Stmt *Base;
|
|
|
|
/// \brief Whether the operator was an arrow ('->'); otherwise, it was a
|
|
/// period ('.').
|
|
bool IsArrow : 1;
|
|
|
|
/// \brief The location of the '.' or '->' operator.
|
|
SourceLocation OperatorLoc;
|
|
|
|
/// \brief The nested-name-specifier that follows the operator, if present.
|
|
NestedNameSpecifierLoc QualifierLoc;
|
|
|
|
/// \brief The type that precedes the '::' in a qualified pseudo-destructor
|
|
/// expression.
|
|
TypeSourceInfo *ScopeType;
|
|
|
|
/// \brief The location of the '::' in a qualified pseudo-destructor
|
|
/// expression.
|
|
SourceLocation ColonColonLoc;
|
|
|
|
/// \brief The location of the '~'.
|
|
SourceLocation TildeLoc;
|
|
|
|
/// \brief The type being destroyed, or its name if we were unable to
|
|
/// resolve the name.
|
|
PseudoDestructorTypeStorage DestroyedType;
|
|
|
|
friend class ASTStmtReader;
|
|
|
|
public:
|
|
CXXPseudoDestructorExpr(const ASTContext &Context,
|
|
Expr *Base, bool isArrow, SourceLocation OperatorLoc,
|
|
NestedNameSpecifierLoc QualifierLoc,
|
|
TypeSourceInfo *ScopeType,
|
|
SourceLocation ColonColonLoc,
|
|
SourceLocation TildeLoc,
|
|
PseudoDestructorTypeStorage DestroyedType);
|
|
|
|
explicit CXXPseudoDestructorExpr(EmptyShell Shell)
|
|
: Expr(CXXPseudoDestructorExprClass, Shell),
|
|
Base(nullptr), IsArrow(false), QualifierLoc(), ScopeType(nullptr) { }
|
|
|
|
Expr *getBase() const { return cast<Expr>(Base); }
|
|
|
|
/// \brief Determines whether this member expression actually had
|
|
/// a C++ nested-name-specifier prior to the name of the member, e.g.,
|
|
/// x->Base::foo.
|
|
bool hasQualifier() const { return QualifierLoc.hasQualifier(); }
|
|
|
|
/// \brief Retrieves the nested-name-specifier that qualifies the type name,
|
|
/// with source-location information.
|
|
NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
|
|
|
|
/// \brief If the member name was qualified, retrieves the
|
|
/// nested-name-specifier that precedes the member name. Otherwise, returns
|
|
/// null.
|
|
NestedNameSpecifier *getQualifier() const {
|
|
return QualifierLoc.getNestedNameSpecifier();
|
|
}
|
|
|
|
/// \brief Determine whether this pseudo-destructor expression was written
|
|
/// using an '->' (otherwise, it used a '.').
|
|
bool isArrow() const { return IsArrow; }
|
|
|
|
/// \brief Retrieve the location of the '.' or '->' operator.
|
|
SourceLocation getOperatorLoc() const { return OperatorLoc; }
|
|
|
|
/// \brief Retrieve the scope type in a qualified pseudo-destructor
|
|
/// expression.
|
|
///
|
|
/// Pseudo-destructor expressions can have extra qualification within them
|
|
/// that is not part of the nested-name-specifier, e.g., \c p->T::~T().
|
|
/// Here, if the object type of the expression is (or may be) a scalar type,
|
|
/// \p T may also be a scalar type and, therefore, cannot be part of a
|
|
/// nested-name-specifier. It is stored as the "scope type" of the pseudo-
|
|
/// destructor expression.
|
|
TypeSourceInfo *getScopeTypeInfo() const { return ScopeType; }
|
|
|
|
/// \brief Retrieve the location of the '::' in a qualified pseudo-destructor
|
|
/// expression.
|
|
SourceLocation getColonColonLoc() const { return ColonColonLoc; }
|
|
|
|
/// \brief Retrieve the location of the '~'.
|
|
SourceLocation getTildeLoc() const { return TildeLoc; }
|
|
|
|
/// \brief Retrieve the source location information for the type
|
|
/// being destroyed.
|
|
///
|
|
/// This type-source information is available for non-dependent
|
|
/// pseudo-destructor expressions and some dependent pseudo-destructor
|
|
/// expressions. Returns null if we only have the identifier for a
|
|
/// dependent pseudo-destructor expression.
|
|
TypeSourceInfo *getDestroyedTypeInfo() const {
|
|
return DestroyedType.getTypeSourceInfo();
|
|
}
|
|
|
|
/// \brief In a dependent pseudo-destructor expression for which we do not
|
|
/// have full type information on the destroyed type, provides the name
|
|
/// of the destroyed type.
|
|
IdentifierInfo *getDestroyedTypeIdentifier() const {
|
|
return DestroyedType.getIdentifier();
|
|
}
|
|
|
|
/// \brief Retrieve the type being destroyed.
|
|
QualType getDestroyedType() const;
|
|
|
|
/// \brief Retrieve the starting location of the type being destroyed.
|
|
SourceLocation getDestroyedTypeLoc() const {
|
|
return DestroyedType.getLocation();
|
|
}
|
|
|
|
/// \brief Set the name of destroyed type for a dependent pseudo-destructor
|
|
/// expression.
|
|
void setDestroyedType(IdentifierInfo *II, SourceLocation Loc) {
|
|
DestroyedType = PseudoDestructorTypeStorage(II, Loc);
|
|
}
|
|
|
|
/// \brief Set the destroyed type.
|
|
void setDestroyedType(TypeSourceInfo *Info) {
|
|
DestroyedType = PseudoDestructorTypeStorage(Info);
|
|
}
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY {return Base->getLocStart();}
|
|
SourceLocation getLocEnd() const LLVM_READONLY;
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXPseudoDestructorExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() { return child_range(&Base, &Base + 1); }
|
|
};
|
|
|
|
/// \brief A type trait used in the implementation of various C++11 and
|
|
/// Library TR1 trait templates.
|
|
///
|
|
/// \code
|
|
/// __is_pod(int) == true
|
|
/// __is_enum(std::string) == false
|
|
/// __is_trivially_constructible(vector<int>, int*, int*)
|
|
/// \endcode
|
|
class TypeTraitExpr : public Expr {
|
|
/// \brief The location of the type trait keyword.
|
|
SourceLocation Loc;
|
|
|
|
/// \brief The location of the closing parenthesis.
|
|
SourceLocation RParenLoc;
|
|
|
|
// Note: The TypeSourceInfos for the arguments are allocated after the
|
|
// TypeTraitExpr.
|
|
|
|
TypeTraitExpr(QualType T, SourceLocation Loc, TypeTrait Kind,
|
|
ArrayRef<TypeSourceInfo *> Args,
|
|
SourceLocation RParenLoc,
|
|
bool Value);
|
|
|
|
TypeTraitExpr(EmptyShell Empty) : Expr(TypeTraitExprClass, Empty) { }
|
|
|
|
/// \brief Retrieve the argument types.
|
|
TypeSourceInfo **getTypeSourceInfos() {
|
|
return reinterpret_cast<TypeSourceInfo **>(this+1);
|
|
}
|
|
|
|
/// \brief Retrieve the argument types.
|
|
TypeSourceInfo * const *getTypeSourceInfos() const {
|
|
return reinterpret_cast<TypeSourceInfo * const*>(this+1);
|
|
}
|
|
|
|
public:
|
|
/// \brief Create a new type trait expression.
|
|
static TypeTraitExpr *Create(const ASTContext &C, QualType T,
|
|
SourceLocation Loc, TypeTrait Kind,
|
|
ArrayRef<TypeSourceInfo *> Args,
|
|
SourceLocation RParenLoc,
|
|
bool Value);
|
|
|
|
static TypeTraitExpr *CreateDeserialized(const ASTContext &C,
|
|
unsigned NumArgs);
|
|
|
|
/// \brief Determine which type trait this expression uses.
|
|
TypeTrait getTrait() const {
|
|
return static_cast<TypeTrait>(TypeTraitExprBits.Kind);
|
|
}
|
|
|
|
bool getValue() const {
|
|
assert(!isValueDependent());
|
|
return TypeTraitExprBits.Value;
|
|
}
|
|
|
|
/// \brief Determine the number of arguments to this type trait.
|
|
unsigned getNumArgs() const { return TypeTraitExprBits.NumArgs; }
|
|
|
|
/// \brief Retrieve the Ith argument.
|
|
TypeSourceInfo *getArg(unsigned I) const {
|
|
assert(I < getNumArgs() && "Argument out-of-range");
|
|
return getArgs()[I];
|
|
}
|
|
|
|
/// \brief Retrieve the argument types.
|
|
ArrayRef<TypeSourceInfo *> getArgs() const {
|
|
return llvm::makeArrayRef(getTypeSourceInfos(), getNumArgs());
|
|
}
|
|
|
|
typedef TypeSourceInfo **arg_iterator;
|
|
arg_iterator arg_begin() {
|
|
return getTypeSourceInfos();
|
|
}
|
|
arg_iterator arg_end() {
|
|
return getTypeSourceInfos() + getNumArgs();
|
|
}
|
|
|
|
typedef TypeSourceInfo const * const *arg_const_iterator;
|
|
arg_const_iterator arg_begin() const { return getTypeSourceInfos(); }
|
|
arg_const_iterator arg_end() const {
|
|
return getTypeSourceInfos() + getNumArgs();
|
|
}
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return RParenLoc; }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == TypeTraitExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() { return child_range(); }
|
|
|
|
friend class ASTStmtReader;
|
|
friend class ASTStmtWriter;
|
|
|
|
};
|
|
|
|
/// \brief An Embarcadero array type trait, as used in the implementation of
|
|
/// __array_rank and __array_extent.
|
|
///
|
|
/// Example:
|
|
/// \code
|
|
/// __array_rank(int[10][20]) == 2
|
|
/// __array_extent(int, 1) == 20
|
|
/// \endcode
|
|
class ArrayTypeTraitExpr : public Expr {
|
|
virtual void anchor();
|
|
|
|
/// \brief The trait. An ArrayTypeTrait enum in MSVC compat unsigned.
|
|
unsigned ATT : 2;
|
|
|
|
/// \brief The value of the type trait. Unspecified if dependent.
|
|
uint64_t Value;
|
|
|
|
/// \brief The array dimension being queried, or -1 if not used.
|
|
Expr *Dimension;
|
|
|
|
/// \brief The location of the type trait keyword.
|
|
SourceLocation Loc;
|
|
|
|
/// \brief The location of the closing paren.
|
|
SourceLocation RParen;
|
|
|
|
/// \brief The type being queried.
|
|
TypeSourceInfo *QueriedType;
|
|
|
|
public:
|
|
ArrayTypeTraitExpr(SourceLocation loc, ArrayTypeTrait att,
|
|
TypeSourceInfo *queried, uint64_t value,
|
|
Expr *dimension, SourceLocation rparen, QualType ty)
|
|
: Expr(ArrayTypeTraitExprClass, ty, VK_RValue, OK_Ordinary,
|
|
false, queried->getType()->isDependentType(),
|
|
(queried->getType()->isInstantiationDependentType() ||
|
|
(dimension && dimension->isInstantiationDependent())),
|
|
queried->getType()->containsUnexpandedParameterPack()),
|
|
ATT(att), Value(value), Dimension(dimension),
|
|
Loc(loc), RParen(rparen), QueriedType(queried) { }
|
|
|
|
|
|
explicit ArrayTypeTraitExpr(EmptyShell Empty)
|
|
: Expr(ArrayTypeTraitExprClass, Empty), ATT(0), Value(false),
|
|
QueriedType() { }
|
|
|
|
virtual ~ArrayTypeTraitExpr() { }
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return RParen; }
|
|
|
|
ArrayTypeTrait getTrait() const { return static_cast<ArrayTypeTrait>(ATT); }
|
|
|
|
QualType getQueriedType() const { return QueriedType->getType(); }
|
|
|
|
TypeSourceInfo *getQueriedTypeSourceInfo() const { return QueriedType; }
|
|
|
|
uint64_t getValue() const { assert(!isTypeDependent()); return Value; }
|
|
|
|
Expr *getDimensionExpression() const { return Dimension; }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == ArrayTypeTraitExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() { return child_range(); }
|
|
|
|
friend class ASTStmtReader;
|
|
};
|
|
|
|
/// \brief An expression trait intrinsic.
|
|
///
|
|
/// Example:
|
|
/// \code
|
|
/// __is_lvalue_expr(std::cout) == true
|
|
/// __is_lvalue_expr(1) == false
|
|
/// \endcode
|
|
class ExpressionTraitExpr : public Expr {
|
|
/// \brief The trait. A ExpressionTrait enum in MSVC compatible unsigned.
|
|
unsigned ET : 31;
|
|
/// \brief The value of the type trait. Unspecified if dependent.
|
|
bool Value : 1;
|
|
|
|
/// \brief The location of the type trait keyword.
|
|
SourceLocation Loc;
|
|
|
|
/// \brief The location of the closing paren.
|
|
SourceLocation RParen;
|
|
|
|
/// \brief The expression being queried.
|
|
Expr* QueriedExpression;
|
|
public:
|
|
ExpressionTraitExpr(SourceLocation loc, ExpressionTrait et,
|
|
Expr *queried, bool value,
|
|
SourceLocation rparen, QualType resultType)
|
|
: Expr(ExpressionTraitExprClass, resultType, VK_RValue, OK_Ordinary,
|
|
false, // Not type-dependent
|
|
// Value-dependent if the argument is type-dependent.
|
|
queried->isTypeDependent(),
|
|
queried->isInstantiationDependent(),
|
|
queried->containsUnexpandedParameterPack()),
|
|
ET(et), Value(value), Loc(loc), RParen(rparen),
|
|
QueriedExpression(queried) { }
|
|
|
|
explicit ExpressionTraitExpr(EmptyShell Empty)
|
|
: Expr(ExpressionTraitExprClass, Empty), ET(0), Value(false),
|
|
QueriedExpression() { }
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY { return Loc; }
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return RParen; }
|
|
|
|
ExpressionTrait getTrait() const { return static_cast<ExpressionTrait>(ET); }
|
|
|
|
Expr *getQueriedExpression() const { return QueriedExpression; }
|
|
|
|
bool getValue() const { return Value; }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == ExpressionTraitExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() { return child_range(); }
|
|
|
|
friend class ASTStmtReader;
|
|
};
|
|
|
|
|
|
/// \brief A reference to an overloaded function set, either an
|
|
/// \c UnresolvedLookupExpr or an \c UnresolvedMemberExpr.
|
|
class OverloadExpr : public Expr {
|
|
/// \brief The common name of these declarations.
|
|
DeclarationNameInfo NameInfo;
|
|
|
|
/// \brief The nested-name-specifier that qualifies the name, if any.
|
|
NestedNameSpecifierLoc QualifierLoc;
|
|
|
|
/// The results. These are undesugared, which is to say, they may
|
|
/// include UsingShadowDecls. Access is relative to the naming
|
|
/// class.
|
|
// FIXME: Allocate this data after the OverloadExpr subclass.
|
|
DeclAccessPair *Results;
|
|
unsigned NumResults;
|
|
|
|
protected:
|
|
/// \brief Whether the name includes info for explicit template
|
|
/// keyword and arguments.
|
|
bool HasTemplateKWAndArgsInfo;
|
|
|
|
/// \brief Return the optional template keyword and arguments info.
|
|
ASTTemplateKWAndArgsInfo *getTemplateKWAndArgsInfo(); // defined far below.
|
|
|
|
/// \brief Return the optional template keyword and arguments info.
|
|
const ASTTemplateKWAndArgsInfo *getTemplateKWAndArgsInfo() const {
|
|
return const_cast<OverloadExpr*>(this)->getTemplateKWAndArgsInfo();
|
|
}
|
|
|
|
OverloadExpr(StmtClass K, const ASTContext &C,
|
|
NestedNameSpecifierLoc QualifierLoc,
|
|
SourceLocation TemplateKWLoc,
|
|
const DeclarationNameInfo &NameInfo,
|
|
const TemplateArgumentListInfo *TemplateArgs,
|
|
UnresolvedSetIterator Begin, UnresolvedSetIterator End,
|
|
bool KnownDependent,
|
|
bool KnownInstantiationDependent,
|
|
bool KnownContainsUnexpandedParameterPack);
|
|
|
|
OverloadExpr(StmtClass K, EmptyShell Empty)
|
|
: Expr(K, Empty), QualifierLoc(), Results(nullptr), NumResults(0),
|
|
HasTemplateKWAndArgsInfo(false) { }
|
|
|
|
void initializeResults(const ASTContext &C,
|
|
UnresolvedSetIterator Begin,
|
|
UnresolvedSetIterator End);
|
|
|
|
public:
|
|
struct FindResult {
|
|
OverloadExpr *Expression;
|
|
bool IsAddressOfOperand;
|
|
bool HasFormOfMemberPointer;
|
|
};
|
|
|
|
/// \brief Finds the overloaded expression in the given expression \p E of
|
|
/// OverloadTy.
|
|
///
|
|
/// \return the expression (which must be there) and true if it has
|
|
/// the particular form of a member pointer expression
|
|
static FindResult find(Expr *E) {
|
|
assert(E->getType()->isSpecificBuiltinType(BuiltinType::Overload));
|
|
|
|
FindResult Result;
|
|
|
|
E = E->IgnoreParens();
|
|
if (isa<UnaryOperator>(E)) {
|
|
assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf);
|
|
E = cast<UnaryOperator>(E)->getSubExpr();
|
|
OverloadExpr *Ovl = cast<OverloadExpr>(E->IgnoreParens());
|
|
|
|
Result.HasFormOfMemberPointer = (E == Ovl && Ovl->getQualifier());
|
|
Result.IsAddressOfOperand = true;
|
|
Result.Expression = Ovl;
|
|
} else {
|
|
Result.HasFormOfMemberPointer = false;
|
|
Result.IsAddressOfOperand = false;
|
|
Result.Expression = cast<OverloadExpr>(E);
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
/// \brief Gets the naming class of this lookup, if any.
|
|
CXXRecordDecl *getNamingClass() const;
|
|
|
|
typedef UnresolvedSetImpl::iterator decls_iterator;
|
|
decls_iterator decls_begin() const { return UnresolvedSetIterator(Results); }
|
|
decls_iterator decls_end() const {
|
|
return UnresolvedSetIterator(Results + NumResults);
|
|
}
|
|
llvm::iterator_range<decls_iterator> decls() const {
|
|
return llvm::iterator_range<decls_iterator>(decls_begin(), decls_end());
|
|
}
|
|
|
|
/// \brief Gets the number of declarations in the unresolved set.
|
|
unsigned getNumDecls() const { return NumResults; }
|
|
|
|
/// \brief Gets the full name info.
|
|
const DeclarationNameInfo &getNameInfo() const { return NameInfo; }
|
|
|
|
/// \brief Gets the name looked up.
|
|
DeclarationName getName() const { return NameInfo.getName(); }
|
|
|
|
/// \brief Gets the location of the name.
|
|
SourceLocation getNameLoc() const { return NameInfo.getLoc(); }
|
|
|
|
/// \brief Fetches the nested-name qualifier, if one was given.
|
|
NestedNameSpecifier *getQualifier() const {
|
|
return QualifierLoc.getNestedNameSpecifier();
|
|
}
|
|
|
|
/// \brief Fetches the nested-name qualifier with source-location
|
|
/// information, if one was given.
|
|
NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
|
|
|
|
/// \brief Retrieve the location of the template keyword preceding
|
|
/// this name, if any.
|
|
SourceLocation getTemplateKeywordLoc() const {
|
|
if (!HasTemplateKWAndArgsInfo) return SourceLocation();
|
|
return getTemplateKWAndArgsInfo()->getTemplateKeywordLoc();
|
|
}
|
|
|
|
/// \brief Retrieve the location of the left angle bracket starting the
|
|
/// explicit template argument list following the name, if any.
|
|
SourceLocation getLAngleLoc() const {
|
|
if (!HasTemplateKWAndArgsInfo) return SourceLocation();
|
|
return getTemplateKWAndArgsInfo()->LAngleLoc;
|
|
}
|
|
|
|
/// \brief Retrieve the location of the right angle bracket ending the
|
|
/// explicit template argument list following the name, if any.
|
|
SourceLocation getRAngleLoc() const {
|
|
if (!HasTemplateKWAndArgsInfo) return SourceLocation();
|
|
return getTemplateKWAndArgsInfo()->RAngleLoc;
|
|
}
|
|
|
|
/// \brief Determines whether the name was preceded by the template keyword.
|
|
bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }
|
|
|
|
/// \brief Determines whether this expression had explicit template arguments.
|
|
bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }
|
|
|
|
// Note that, inconsistently with the explicit-template-argument AST
|
|
// nodes, users are *forbidden* from calling these methods on objects
|
|
// without explicit template arguments.
|
|
|
|
ASTTemplateArgumentListInfo &getExplicitTemplateArgs() {
|
|
assert(hasExplicitTemplateArgs());
|
|
return *getTemplateKWAndArgsInfo();
|
|
}
|
|
|
|
const ASTTemplateArgumentListInfo &getExplicitTemplateArgs() const {
|
|
return const_cast<OverloadExpr*>(this)->getExplicitTemplateArgs();
|
|
}
|
|
|
|
TemplateArgumentLoc const *getTemplateArgs() const {
|
|
return getExplicitTemplateArgs().getTemplateArgs();
|
|
}
|
|
|
|
unsigned getNumTemplateArgs() const {
|
|
return getExplicitTemplateArgs().NumTemplateArgs;
|
|
}
|
|
|
|
/// \brief Copies the template arguments into the given structure.
|
|
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
|
|
getExplicitTemplateArgs().copyInto(List);
|
|
}
|
|
|
|
/// \brief Retrieves the optional explicit template arguments.
|
|
///
|
|
/// This points to the same data as getExplicitTemplateArgs(), but
|
|
/// returns null if there are no explicit template arguments.
|
|
const ASTTemplateArgumentListInfo *getOptionalExplicitTemplateArgs() const {
|
|
if (!hasExplicitTemplateArgs()) return nullptr;
|
|
return &getExplicitTemplateArgs();
|
|
}
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == UnresolvedLookupExprClass ||
|
|
T->getStmtClass() == UnresolvedMemberExprClass;
|
|
}
|
|
|
|
friend class ASTStmtReader;
|
|
friend class ASTStmtWriter;
|
|
};
|
|
|
|
/// \brief A reference to a name which we were able to look up during
|
|
/// parsing but could not resolve to a specific declaration.
|
|
///
|
|
/// This arises in several ways:
|
|
/// * we might be waiting for argument-dependent lookup;
|
|
/// * the name might resolve to an overloaded function;
|
|
/// and eventually:
|
|
/// * the lookup might have included a function template.
|
|
///
|
|
/// These never include UnresolvedUsingValueDecls, which are always class
|
|
/// members and therefore appear only in UnresolvedMemberLookupExprs.
|
|
class UnresolvedLookupExpr : public OverloadExpr {
|
|
/// True if these lookup results should be extended by
|
|
/// argument-dependent lookup if this is the operand of a function
|
|
/// call.
|
|
bool RequiresADL;
|
|
|
|
/// True if these lookup results are overloaded. This is pretty
|
|
/// trivially rederivable if we urgently need to kill this field.
|
|
bool Overloaded;
|
|
|
|
/// The naming class (C++ [class.access.base]p5) of the lookup, if
|
|
/// any. This can generally be recalculated from the context chain,
|
|
/// but that can be fairly expensive for unqualified lookups. If we
|
|
/// want to improve memory use here, this could go in a union
|
|
/// against the qualified-lookup bits.
|
|
CXXRecordDecl *NamingClass;
|
|
|
|
UnresolvedLookupExpr(const ASTContext &C,
|
|
CXXRecordDecl *NamingClass,
|
|
NestedNameSpecifierLoc QualifierLoc,
|
|
SourceLocation TemplateKWLoc,
|
|
const DeclarationNameInfo &NameInfo,
|
|
bool RequiresADL, bool Overloaded,
|
|
const TemplateArgumentListInfo *TemplateArgs,
|
|
UnresolvedSetIterator Begin, UnresolvedSetIterator End)
|
|
: OverloadExpr(UnresolvedLookupExprClass, C, QualifierLoc, TemplateKWLoc,
|
|
NameInfo, TemplateArgs, Begin, End, false, false, false),
|
|
RequiresADL(RequiresADL),
|
|
Overloaded(Overloaded), NamingClass(NamingClass)
|
|
{}
|
|
|
|
UnresolvedLookupExpr(EmptyShell Empty)
|
|
: OverloadExpr(UnresolvedLookupExprClass, Empty),
|
|
RequiresADL(false), Overloaded(false), NamingClass(nullptr)
|
|
{}
|
|
|
|
friend class ASTStmtReader;
|
|
|
|
public:
|
|
static UnresolvedLookupExpr *Create(const ASTContext &C,
|
|
CXXRecordDecl *NamingClass,
|
|
NestedNameSpecifierLoc QualifierLoc,
|
|
const DeclarationNameInfo &NameInfo,
|
|
bool ADL, bool Overloaded,
|
|
UnresolvedSetIterator Begin,
|
|
UnresolvedSetIterator End) {
|
|
return new(C) UnresolvedLookupExpr(C, NamingClass, QualifierLoc,
|
|
SourceLocation(), NameInfo,
|
|
ADL, Overloaded, nullptr, Begin, End);
|
|
}
|
|
|
|
static UnresolvedLookupExpr *Create(const ASTContext &C,
|
|
CXXRecordDecl *NamingClass,
|
|
NestedNameSpecifierLoc QualifierLoc,
|
|
SourceLocation TemplateKWLoc,
|
|
const DeclarationNameInfo &NameInfo,
|
|
bool ADL,
|
|
const TemplateArgumentListInfo *Args,
|
|
UnresolvedSetIterator Begin,
|
|
UnresolvedSetIterator End);
|
|
|
|
static UnresolvedLookupExpr *CreateEmpty(const ASTContext &C,
|
|
bool HasTemplateKWAndArgsInfo,
|
|
unsigned NumTemplateArgs);
|
|
|
|
/// True if this declaration should be extended by
|
|
/// argument-dependent lookup.
|
|
bool requiresADL() const { return RequiresADL; }
|
|
|
|
/// True if this lookup is overloaded.
|
|
bool isOverloaded() const { return Overloaded; }
|
|
|
|
/// Gets the 'naming class' (in the sense of C++0x
|
|
/// [class.access.base]p5) of the lookup. This is the scope
|
|
/// that was looked in to find these results.
|
|
CXXRecordDecl *getNamingClass() const { return NamingClass; }
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY {
|
|
if (NestedNameSpecifierLoc l = getQualifierLoc())
|
|
return l.getBeginLoc();
|
|
return getNameInfo().getLocStart();
|
|
}
|
|
SourceLocation getLocEnd() const LLVM_READONLY {
|
|
if (hasExplicitTemplateArgs())
|
|
return getRAngleLoc();
|
|
return getNameInfo().getLocEnd();
|
|
}
|
|
|
|
child_range children() { return child_range(); }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == UnresolvedLookupExprClass;
|
|
}
|
|
};
|
|
|
|
/// \brief A qualified reference to a name whose declaration cannot
|
|
/// yet be resolved.
|
|
///
|
|
/// DependentScopeDeclRefExpr is similar to DeclRefExpr in that
|
|
/// it expresses a reference to a declaration such as
|
|
/// X<T>::value. The difference, however, is that an
|
|
/// DependentScopeDeclRefExpr node is used only within C++ templates when
|
|
/// the qualification (e.g., X<T>::) refers to a dependent type. In
|
|
/// this case, X<T>::value cannot resolve to a declaration because the
|
|
/// declaration will differ from one instantiation of X<T> to the
|
|
/// next. Therefore, DependentScopeDeclRefExpr keeps track of the
|
|
/// qualifier (X<T>::) and the name of the entity being referenced
|
|
/// ("value"). Such expressions will instantiate to a DeclRefExpr once the
|
|
/// declaration can be found.
|
|
class DependentScopeDeclRefExpr : public Expr {
|
|
/// \brief The nested-name-specifier that qualifies this unresolved
|
|
/// declaration name.
|
|
NestedNameSpecifierLoc QualifierLoc;
|
|
|
|
/// \brief The name of the entity we will be referencing.
|
|
DeclarationNameInfo NameInfo;
|
|
|
|
/// \brief Whether the name includes info for explicit template
|
|
/// keyword and arguments.
|
|
bool HasTemplateKWAndArgsInfo;
|
|
|
|
/// \brief Return the optional template keyword and arguments info.
|
|
ASTTemplateKWAndArgsInfo *getTemplateKWAndArgsInfo() {
|
|
if (!HasTemplateKWAndArgsInfo) return nullptr;
|
|
return reinterpret_cast<ASTTemplateKWAndArgsInfo*>(this + 1);
|
|
}
|
|
/// \brief Return the optional template keyword and arguments info.
|
|
const ASTTemplateKWAndArgsInfo *getTemplateKWAndArgsInfo() const {
|
|
return const_cast<DependentScopeDeclRefExpr*>(this)
|
|
->getTemplateKWAndArgsInfo();
|
|
}
|
|
|
|
DependentScopeDeclRefExpr(QualType T,
|
|
NestedNameSpecifierLoc QualifierLoc,
|
|
SourceLocation TemplateKWLoc,
|
|
const DeclarationNameInfo &NameInfo,
|
|
const TemplateArgumentListInfo *Args);
|
|
|
|
public:
|
|
static DependentScopeDeclRefExpr *Create(const ASTContext &C,
|
|
NestedNameSpecifierLoc QualifierLoc,
|
|
SourceLocation TemplateKWLoc,
|
|
const DeclarationNameInfo &NameInfo,
|
|
const TemplateArgumentListInfo *TemplateArgs);
|
|
|
|
static DependentScopeDeclRefExpr *CreateEmpty(const ASTContext &C,
|
|
bool HasTemplateKWAndArgsInfo,
|
|
unsigned NumTemplateArgs);
|
|
|
|
/// \brief Retrieve the name that this expression refers to.
|
|
const DeclarationNameInfo &getNameInfo() const { return NameInfo; }
|
|
|
|
/// \brief Retrieve the name that this expression refers to.
|
|
DeclarationName getDeclName() const { return NameInfo.getName(); }
|
|
|
|
/// \brief Retrieve the location of the name within the expression.
|
|
///
|
|
/// For example, in "X<T>::value" this is the location of "value".
|
|
SourceLocation getLocation() const { return NameInfo.getLoc(); }
|
|
|
|
/// \brief Retrieve the nested-name-specifier that qualifies the
|
|
/// name, with source location information.
|
|
NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
|
|
|
|
/// \brief Retrieve the nested-name-specifier that qualifies this
|
|
/// declaration.
|
|
NestedNameSpecifier *getQualifier() const {
|
|
return QualifierLoc.getNestedNameSpecifier();
|
|
}
|
|
|
|
/// \brief Retrieve the location of the template keyword preceding
|
|
/// this name, if any.
|
|
SourceLocation getTemplateKeywordLoc() const {
|
|
if (!HasTemplateKWAndArgsInfo) return SourceLocation();
|
|
return getTemplateKWAndArgsInfo()->getTemplateKeywordLoc();
|
|
}
|
|
|
|
/// \brief Retrieve the location of the left angle bracket starting the
|
|
/// explicit template argument list following the name, if any.
|
|
SourceLocation getLAngleLoc() const {
|
|
if (!HasTemplateKWAndArgsInfo) return SourceLocation();
|
|
return getTemplateKWAndArgsInfo()->LAngleLoc;
|
|
}
|
|
|
|
/// \brief Retrieve the location of the right angle bracket ending the
|
|
/// explicit template argument list following the name, if any.
|
|
SourceLocation getRAngleLoc() const {
|
|
if (!HasTemplateKWAndArgsInfo) return SourceLocation();
|
|
return getTemplateKWAndArgsInfo()->RAngleLoc;
|
|
}
|
|
|
|
/// Determines whether the name was preceded by the template keyword.
|
|
bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }
|
|
|
|
/// Determines whether this lookup had explicit template arguments.
|
|
bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }
|
|
|
|
// Note that, inconsistently with the explicit-template-argument AST
|
|
// nodes, users are *forbidden* from calling these methods on objects
|
|
// without explicit template arguments.
|
|
|
|
ASTTemplateArgumentListInfo &getExplicitTemplateArgs() {
|
|
assert(hasExplicitTemplateArgs());
|
|
return *reinterpret_cast<ASTTemplateArgumentListInfo*>(this + 1);
|
|
}
|
|
|
|
/// Gets a reference to the explicit template argument list.
|
|
const ASTTemplateArgumentListInfo &getExplicitTemplateArgs() const {
|
|
assert(hasExplicitTemplateArgs());
|
|
return *reinterpret_cast<const ASTTemplateArgumentListInfo*>(this + 1);
|
|
}
|
|
|
|
/// \brief Retrieves the optional explicit template arguments.
|
|
///
|
|
/// This points to the same data as getExplicitTemplateArgs(), but
|
|
/// returns null if there are no explicit template arguments.
|
|
const ASTTemplateArgumentListInfo *getOptionalExplicitTemplateArgs() const {
|
|
if (!hasExplicitTemplateArgs()) return nullptr;
|
|
return &getExplicitTemplateArgs();
|
|
}
|
|
|
|
/// \brief Copies the template arguments (if present) into the given
|
|
/// structure.
|
|
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
|
|
getExplicitTemplateArgs().copyInto(List);
|
|
}
|
|
|
|
TemplateArgumentLoc const *getTemplateArgs() const {
|
|
return getExplicitTemplateArgs().getTemplateArgs();
|
|
}
|
|
|
|
unsigned getNumTemplateArgs() const {
|
|
return getExplicitTemplateArgs().NumTemplateArgs;
|
|
}
|
|
|
|
/// Note: getLocStart() is the start of the whole DependentScopeDeclRefExpr,
|
|
/// and differs from getLocation().getStart().
|
|
SourceLocation getLocStart() const LLVM_READONLY {
|
|
return QualifierLoc.getBeginLoc();
|
|
}
|
|
SourceLocation getLocEnd() const LLVM_READONLY {
|
|
if (hasExplicitTemplateArgs())
|
|
return getRAngleLoc();
|
|
return getLocation();
|
|
}
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == DependentScopeDeclRefExprClass;
|
|
}
|
|
|
|
child_range children() { return child_range(); }
|
|
|
|
friend class ASTStmtReader;
|
|
friend class ASTStmtWriter;
|
|
};
|
|
|
|
/// Represents an expression -- generally a full-expression -- that
|
|
/// introduces cleanups to be run at the end of the sub-expression's
|
|
/// evaluation. The most common source of expression-introduced
|
|
/// cleanups is temporary objects in C++, but several other kinds of
|
|
/// expressions can create cleanups, including basically every
|
|
/// call in ARC that returns an Objective-C pointer.
|
|
///
|
|
/// This expression also tracks whether the sub-expression contains a
|
|
/// potentially-evaluated block literal. The lifetime of a block
|
|
/// literal is the extent of the enclosing scope.
|
|
class ExprWithCleanups : public Expr {
|
|
public:
|
|
/// The type of objects that are kept in the cleanup.
|
|
/// It's useful to remember the set of blocks; we could also
|
|
/// remember the set of temporaries, but there's currently
|
|
/// no need.
|
|
typedef BlockDecl *CleanupObject;
|
|
|
|
private:
|
|
Stmt *SubExpr;
|
|
|
|
ExprWithCleanups(EmptyShell, unsigned NumObjects);
|
|
ExprWithCleanups(Expr *SubExpr, ArrayRef<CleanupObject> Objects);
|
|
|
|
CleanupObject *getObjectsBuffer() {
|
|
return reinterpret_cast<CleanupObject*>(this + 1);
|
|
}
|
|
const CleanupObject *getObjectsBuffer() const {
|
|
return reinterpret_cast<const CleanupObject*>(this + 1);
|
|
}
|
|
friend class ASTStmtReader;
|
|
|
|
public:
|
|
static ExprWithCleanups *Create(const ASTContext &C, EmptyShell empty,
|
|
unsigned numObjects);
|
|
|
|
static ExprWithCleanups *Create(const ASTContext &C, Expr *subexpr,
|
|
ArrayRef<CleanupObject> objects);
|
|
|
|
ArrayRef<CleanupObject> getObjects() const {
|
|
return llvm::makeArrayRef(getObjectsBuffer(), getNumObjects());
|
|
}
|
|
|
|
unsigned getNumObjects() const { return ExprWithCleanupsBits.NumObjects; }
|
|
|
|
CleanupObject getObject(unsigned i) const {
|
|
assert(i < getNumObjects() && "Index out of range");
|
|
return getObjects()[i];
|
|
}
|
|
|
|
Expr *getSubExpr() { return cast<Expr>(SubExpr); }
|
|
const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
|
|
|
|
/// As with any mutator of the AST, be very careful
|
|
/// when modifying an existing AST to preserve its invariants.
|
|
void setSubExpr(Expr *E) { SubExpr = E; }
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY {
|
|
return SubExpr->getLocStart();
|
|
}
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return SubExpr->getLocEnd();}
|
|
|
|
// Implement isa/cast/dyncast/etc.
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == ExprWithCleanupsClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() { return child_range(&SubExpr, &SubExpr + 1); }
|
|
};
|
|
|
|
/// \brief Describes an explicit type conversion that uses functional
|
|
/// notion but could not be resolved because one or more arguments are
|
|
/// type-dependent.
|
|
///
|
|
/// The explicit type conversions expressed by
|
|
/// CXXUnresolvedConstructExpr have the form <tt>T(a1, a2, ..., aN)</tt>,
|
|
/// where \c T is some type and \c a1, \c a2, ..., \c aN are values, and
|
|
/// either \c T is a dependent type or one or more of the <tt>a</tt>'s is
|
|
/// type-dependent. For example, this would occur in a template such
|
|
/// as:
|
|
///
|
|
/// \code
|
|
/// template<typename T, typename A1>
|
|
/// inline T make_a(const A1& a1) {
|
|
/// return T(a1);
|
|
/// }
|
|
/// \endcode
|
|
///
|
|
/// When the returned expression is instantiated, it may resolve to a
|
|
/// constructor call, conversion function call, or some kind of type
|
|
/// conversion.
|
|
class CXXUnresolvedConstructExpr : public Expr {
|
|
/// \brief The type being constructed.
|
|
TypeSourceInfo *Type;
|
|
|
|
/// \brief The location of the left parentheses ('(').
|
|
SourceLocation LParenLoc;
|
|
|
|
/// \brief The location of the right parentheses (')').
|
|
SourceLocation RParenLoc;
|
|
|
|
/// \brief The number of arguments used to construct the type.
|
|
unsigned NumArgs;
|
|
|
|
CXXUnresolvedConstructExpr(TypeSourceInfo *Type,
|
|
SourceLocation LParenLoc,
|
|
ArrayRef<Expr*> Args,
|
|
SourceLocation RParenLoc);
|
|
|
|
CXXUnresolvedConstructExpr(EmptyShell Empty, unsigned NumArgs)
|
|
: Expr(CXXUnresolvedConstructExprClass, Empty), Type(), NumArgs(NumArgs) { }
|
|
|
|
friend class ASTStmtReader;
|
|
|
|
public:
|
|
static CXXUnresolvedConstructExpr *Create(const ASTContext &C,
|
|
TypeSourceInfo *Type,
|
|
SourceLocation LParenLoc,
|
|
ArrayRef<Expr*> Args,
|
|
SourceLocation RParenLoc);
|
|
|
|
static CXXUnresolvedConstructExpr *CreateEmpty(const ASTContext &C,
|
|
unsigned NumArgs);
|
|
|
|
/// \brief Retrieve the type that is being constructed, as specified
|
|
/// in the source code.
|
|
QualType getTypeAsWritten() const { return Type->getType(); }
|
|
|
|
/// \brief Retrieve the type source information for the type being
|
|
/// constructed.
|
|
TypeSourceInfo *getTypeSourceInfo() const { return Type; }
|
|
|
|
/// \brief Retrieve the location of the left parentheses ('(') that
|
|
/// precedes the argument list.
|
|
SourceLocation getLParenLoc() const { return LParenLoc; }
|
|
void setLParenLoc(SourceLocation L) { LParenLoc = L; }
|
|
|
|
/// \brief Retrieve the location of the right parentheses (')') that
|
|
/// follows the argument list.
|
|
SourceLocation getRParenLoc() const { return RParenLoc; }
|
|
void setRParenLoc(SourceLocation L) { RParenLoc = L; }
|
|
|
|
/// \brief Retrieve the number of arguments.
|
|
unsigned arg_size() const { return NumArgs; }
|
|
|
|
typedef Expr** arg_iterator;
|
|
arg_iterator arg_begin() { return reinterpret_cast<Expr**>(this + 1); }
|
|
arg_iterator arg_end() { return arg_begin() + NumArgs; }
|
|
|
|
typedef const Expr* const * const_arg_iterator;
|
|
const_arg_iterator arg_begin() const {
|
|
return reinterpret_cast<const Expr* const *>(this + 1);
|
|
}
|
|
const_arg_iterator arg_end() const {
|
|
return arg_begin() + NumArgs;
|
|
}
|
|
|
|
Expr *getArg(unsigned I) {
|
|
assert(I < NumArgs && "Argument index out-of-range");
|
|
return *(arg_begin() + I);
|
|
}
|
|
|
|
const Expr *getArg(unsigned I) const {
|
|
assert(I < NumArgs && "Argument index out-of-range");
|
|
return *(arg_begin() + I);
|
|
}
|
|
|
|
void setArg(unsigned I, Expr *E) {
|
|
assert(I < NumArgs && "Argument index out-of-range");
|
|
*(arg_begin() + I) = E;
|
|
}
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY;
|
|
SourceLocation getLocEnd() const LLVM_READONLY {
|
|
if (!RParenLoc.isValid() && NumArgs > 0)
|
|
return getArg(NumArgs - 1)->getLocEnd();
|
|
return RParenLoc;
|
|
}
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXUnresolvedConstructExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() {
|
|
Stmt **begin = reinterpret_cast<Stmt**>(this+1);
|
|
return child_range(begin, begin + NumArgs);
|
|
}
|
|
};
|
|
|
|
/// \brief Represents a C++ member access expression where the actual
|
|
/// member referenced could not be resolved because the base
|
|
/// expression or the member name was dependent.
|
|
///
|
|
/// Like UnresolvedMemberExprs, these can be either implicit or
|
|
/// explicit accesses. It is only possible to get one of these with
|
|
/// an implicit access if a qualifier is provided.
|
|
class CXXDependentScopeMemberExpr : public Expr {
|
|
/// \brief The expression for the base pointer or class reference,
|
|
/// e.g., the \c x in x.f. Can be null in implicit accesses.
|
|
Stmt *Base;
|
|
|
|
/// \brief The type of the base expression. Never null, even for
|
|
/// implicit accesses.
|
|
QualType BaseType;
|
|
|
|
/// \brief Whether this member expression used the '->' operator or
|
|
/// the '.' operator.
|
|
bool IsArrow : 1;
|
|
|
|
/// \brief Whether this member expression has info for explicit template
|
|
/// keyword and arguments.
|
|
bool HasTemplateKWAndArgsInfo : 1;
|
|
|
|
/// \brief The location of the '->' or '.' operator.
|
|
SourceLocation OperatorLoc;
|
|
|
|
/// \brief The nested-name-specifier that precedes the member name, if any.
|
|
NestedNameSpecifierLoc QualifierLoc;
|
|
|
|
/// \brief In a qualified member access expression such as t->Base::f, this
|
|
/// member stores the resolves of name lookup in the context of the member
|
|
/// access expression, to be used at instantiation time.
|
|
///
|
|
/// FIXME: This member, along with the QualifierLoc, could
|
|
/// be stuck into a structure that is optionally allocated at the end of
|
|
/// the CXXDependentScopeMemberExpr, to save space in the common case.
|
|
NamedDecl *FirstQualifierFoundInScope;
|
|
|
|
/// \brief The member to which this member expression refers, which
|
|
/// can be name, overloaded operator, or destructor.
|
|
///
|
|
/// FIXME: could also be a template-id
|
|
DeclarationNameInfo MemberNameInfo;
|
|
|
|
/// \brief Return the optional template keyword and arguments info.
|
|
ASTTemplateKWAndArgsInfo *getTemplateKWAndArgsInfo() {
|
|
if (!HasTemplateKWAndArgsInfo) return nullptr;
|
|
return reinterpret_cast<ASTTemplateKWAndArgsInfo*>(this + 1);
|
|
}
|
|
/// \brief Return the optional template keyword and arguments info.
|
|
const ASTTemplateKWAndArgsInfo *getTemplateKWAndArgsInfo() const {
|
|
return const_cast<CXXDependentScopeMemberExpr*>(this)
|
|
->getTemplateKWAndArgsInfo();
|
|
}
|
|
|
|
CXXDependentScopeMemberExpr(const ASTContext &C, Expr *Base,
|
|
QualType BaseType, bool IsArrow,
|
|
SourceLocation OperatorLoc,
|
|
NestedNameSpecifierLoc QualifierLoc,
|
|
SourceLocation TemplateKWLoc,
|
|
NamedDecl *FirstQualifierFoundInScope,
|
|
DeclarationNameInfo MemberNameInfo,
|
|
const TemplateArgumentListInfo *TemplateArgs);
|
|
|
|
public:
|
|
CXXDependentScopeMemberExpr(const ASTContext &C, Expr *Base,
|
|
QualType BaseType, bool IsArrow,
|
|
SourceLocation OperatorLoc,
|
|
NestedNameSpecifierLoc QualifierLoc,
|
|
NamedDecl *FirstQualifierFoundInScope,
|
|
DeclarationNameInfo MemberNameInfo);
|
|
|
|
static CXXDependentScopeMemberExpr *
|
|
Create(const ASTContext &C, Expr *Base, QualType BaseType, bool IsArrow,
|
|
SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc,
|
|
SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope,
|
|
DeclarationNameInfo MemberNameInfo,
|
|
const TemplateArgumentListInfo *TemplateArgs);
|
|
|
|
static CXXDependentScopeMemberExpr *
|
|
CreateEmpty(const ASTContext &C, bool HasTemplateKWAndArgsInfo,
|
|
unsigned NumTemplateArgs);
|
|
|
|
/// \brief True if this is an implicit access, i.e. one in which the
|
|
/// member being accessed was not written in the source. The source
|
|
/// location of the operator is invalid in this case.
|
|
bool isImplicitAccess() const;
|
|
|
|
/// \brief Retrieve the base object of this member expressions,
|
|
/// e.g., the \c x in \c x.m.
|
|
Expr *getBase() const {
|
|
assert(!isImplicitAccess());
|
|
return cast<Expr>(Base);
|
|
}
|
|
|
|
QualType getBaseType() const { return BaseType; }
|
|
|
|
/// \brief Determine whether this member expression used the '->'
|
|
/// operator; otherwise, it used the '.' operator.
|
|
bool isArrow() const { return IsArrow; }
|
|
|
|
/// \brief Retrieve the location of the '->' or '.' operator.
|
|
SourceLocation getOperatorLoc() const { return OperatorLoc; }
|
|
|
|
/// \brief Retrieve the nested-name-specifier that qualifies the member
|
|
/// name.
|
|
NestedNameSpecifier *getQualifier() const {
|
|
return QualifierLoc.getNestedNameSpecifier();
|
|
}
|
|
|
|
/// \brief Retrieve the nested-name-specifier that qualifies the member
|
|
/// name, with source location information.
|
|
NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
|
|
|
|
|
|
/// \brief Retrieve the first part of the nested-name-specifier that was
|
|
/// found in the scope of the member access expression when the member access
|
|
/// was initially parsed.
|
|
///
|
|
/// This function only returns a useful result when member access expression
|
|
/// uses a qualified member name, e.g., "x.Base::f". Here, the declaration
|
|
/// returned by this function describes what was found by unqualified name
|
|
/// lookup for the identifier "Base" within the scope of the member access
|
|
/// expression itself. At template instantiation time, this information is
|
|
/// combined with the results of name lookup into the type of the object
|
|
/// expression itself (the class type of x).
|
|
NamedDecl *getFirstQualifierFoundInScope() const {
|
|
return FirstQualifierFoundInScope;
|
|
}
|
|
|
|
/// \brief Retrieve the name of the member that this expression
|
|
/// refers to.
|
|
const DeclarationNameInfo &getMemberNameInfo() const {
|
|
return MemberNameInfo;
|
|
}
|
|
|
|
/// \brief Retrieve the name of the member that this expression
|
|
/// refers to.
|
|
DeclarationName getMember() const { return MemberNameInfo.getName(); }
|
|
|
|
// \brief Retrieve the location of the name of the member that this
|
|
// expression refers to.
|
|
SourceLocation getMemberLoc() const { return MemberNameInfo.getLoc(); }
|
|
|
|
/// \brief Retrieve the location of the template keyword preceding the
|
|
/// member name, if any.
|
|
SourceLocation getTemplateKeywordLoc() const {
|
|
if (!HasTemplateKWAndArgsInfo) return SourceLocation();
|
|
return getTemplateKWAndArgsInfo()->getTemplateKeywordLoc();
|
|
}
|
|
|
|
/// \brief Retrieve the location of the left angle bracket starting the
|
|
/// explicit template argument list following the member name, if any.
|
|
SourceLocation getLAngleLoc() const {
|
|
if (!HasTemplateKWAndArgsInfo) return SourceLocation();
|
|
return getTemplateKWAndArgsInfo()->LAngleLoc;
|
|
}
|
|
|
|
/// \brief Retrieve the location of the right angle bracket ending the
|
|
/// explicit template argument list following the member name, if any.
|
|
SourceLocation getRAngleLoc() const {
|
|
if (!HasTemplateKWAndArgsInfo) return SourceLocation();
|
|
return getTemplateKWAndArgsInfo()->RAngleLoc;
|
|
}
|
|
|
|
/// Determines whether the member name was preceded by the template keyword.
|
|
bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }
|
|
|
|
/// \brief Determines whether this member expression actually had a C++
|
|
/// template argument list explicitly specified, e.g., x.f<int>.
|
|
bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }
|
|
|
|
/// \brief Retrieve the explicit template argument list that followed the
|
|
/// member template name, if any.
|
|
ASTTemplateArgumentListInfo &getExplicitTemplateArgs() {
|
|
assert(hasExplicitTemplateArgs());
|
|
return *reinterpret_cast<ASTTemplateArgumentListInfo *>(this + 1);
|
|
}
|
|
|
|
/// \brief Retrieve the explicit template argument list that followed the
|
|
/// member template name, if any.
|
|
const ASTTemplateArgumentListInfo &getExplicitTemplateArgs() const {
|
|
return const_cast<CXXDependentScopeMemberExpr *>(this)
|
|
->getExplicitTemplateArgs();
|
|
}
|
|
|
|
/// \brief Retrieves the optional explicit template arguments.
|
|
///
|
|
/// This points to the same data as getExplicitTemplateArgs(), but
|
|
/// returns null if there are no explicit template arguments.
|
|
const ASTTemplateArgumentListInfo *getOptionalExplicitTemplateArgs() const {
|
|
if (!hasExplicitTemplateArgs()) return nullptr;
|
|
return &getExplicitTemplateArgs();
|
|
}
|
|
|
|
/// \brief Copies the template arguments (if present) into the given
|
|
/// structure.
|
|
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
|
|
getExplicitTemplateArgs().copyInto(List);
|
|
}
|
|
|
|
/// \brief Initializes the template arguments using the given structure.
|
|
void initializeTemplateArgumentsFrom(const TemplateArgumentListInfo &List) {
|
|
getExplicitTemplateArgs().initializeFrom(List);
|
|
}
|
|
|
|
/// \brief Retrieve the template arguments provided as part of this
|
|
/// template-id.
|
|
const TemplateArgumentLoc *getTemplateArgs() const {
|
|
return getExplicitTemplateArgs().getTemplateArgs();
|
|
}
|
|
|
|
/// \brief Retrieve the number of template arguments provided as part of this
|
|
/// template-id.
|
|
unsigned getNumTemplateArgs() const {
|
|
return getExplicitTemplateArgs().NumTemplateArgs;
|
|
}
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY {
|
|
if (!isImplicitAccess())
|
|
return Base->getLocStart();
|
|
if (getQualifier())
|
|
return getQualifierLoc().getBeginLoc();
|
|
return MemberNameInfo.getBeginLoc();
|
|
|
|
}
|
|
SourceLocation getLocEnd() const LLVM_READONLY {
|
|
if (hasExplicitTemplateArgs())
|
|
return getRAngleLoc();
|
|
return MemberNameInfo.getEndLoc();
|
|
}
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXDependentScopeMemberExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() {
|
|
if (isImplicitAccess()) return child_range();
|
|
return child_range(&Base, &Base + 1);
|
|
}
|
|
|
|
friend class ASTStmtReader;
|
|
friend class ASTStmtWriter;
|
|
};
|
|
|
|
/// \brief Represents a C++ member access expression for which lookup
|
|
/// produced a set of overloaded functions.
|
|
///
|
|
/// The member access may be explicit or implicit:
|
|
/// \code
|
|
/// struct A {
|
|
/// int a, b;
|
|
/// int explicitAccess() { return this->a + this->A::b; }
|
|
/// int implicitAccess() { return a + A::b; }
|
|
/// };
|
|
/// \endcode
|
|
///
|
|
/// In the final AST, an explicit access always becomes a MemberExpr.
|
|
/// An implicit access may become either a MemberExpr or a
|
|
/// DeclRefExpr, depending on whether the member is static.
|
|
class UnresolvedMemberExpr : public OverloadExpr {
|
|
/// \brief Whether this member expression used the '->' operator or
|
|
/// the '.' operator.
|
|
bool IsArrow : 1;
|
|
|
|
/// \brief Whether the lookup results contain an unresolved using
|
|
/// declaration.
|
|
bool HasUnresolvedUsing : 1;
|
|
|
|
/// \brief The expression for the base pointer or class reference,
|
|
/// e.g., the \c x in x.f.
|
|
///
|
|
/// This can be null if this is an 'unbased' member expression.
|
|
Stmt *Base;
|
|
|
|
/// \brief The type of the base expression; never null.
|
|
QualType BaseType;
|
|
|
|
/// \brief The location of the '->' or '.' operator.
|
|
SourceLocation OperatorLoc;
|
|
|
|
UnresolvedMemberExpr(const ASTContext &C, bool HasUnresolvedUsing,
|
|
Expr *Base, QualType BaseType, bool IsArrow,
|
|
SourceLocation OperatorLoc,
|
|
NestedNameSpecifierLoc QualifierLoc,
|
|
SourceLocation TemplateKWLoc,
|
|
const DeclarationNameInfo &MemberNameInfo,
|
|
const TemplateArgumentListInfo *TemplateArgs,
|
|
UnresolvedSetIterator Begin, UnresolvedSetIterator End);
|
|
|
|
UnresolvedMemberExpr(EmptyShell Empty)
|
|
: OverloadExpr(UnresolvedMemberExprClass, Empty), IsArrow(false),
|
|
HasUnresolvedUsing(false), Base(nullptr) { }
|
|
|
|
friend class ASTStmtReader;
|
|
|
|
public:
|
|
static UnresolvedMemberExpr *
|
|
Create(const ASTContext &C, bool HasUnresolvedUsing,
|
|
Expr *Base, QualType BaseType, bool IsArrow,
|
|
SourceLocation OperatorLoc,
|
|
NestedNameSpecifierLoc QualifierLoc,
|
|
SourceLocation TemplateKWLoc,
|
|
const DeclarationNameInfo &MemberNameInfo,
|
|
const TemplateArgumentListInfo *TemplateArgs,
|
|
UnresolvedSetIterator Begin, UnresolvedSetIterator End);
|
|
|
|
static UnresolvedMemberExpr *
|
|
CreateEmpty(const ASTContext &C, bool HasTemplateKWAndArgsInfo,
|
|
unsigned NumTemplateArgs);
|
|
|
|
/// \brief True if this is an implicit access, i.e., one in which the
|
|
/// member being accessed was not written in the source.
|
|
///
|
|
/// The source location of the operator is invalid in this case.
|
|
bool isImplicitAccess() const;
|
|
|
|
/// \brief Retrieve the base object of this member expressions,
|
|
/// e.g., the \c x in \c x.m.
|
|
Expr *getBase() {
|
|
assert(!isImplicitAccess());
|
|
return cast<Expr>(Base);
|
|
}
|
|
const Expr *getBase() const {
|
|
assert(!isImplicitAccess());
|
|
return cast<Expr>(Base);
|
|
}
|
|
|
|
QualType getBaseType() const { return BaseType; }
|
|
|
|
/// \brief Determine whether the lookup results contain an unresolved using
|
|
/// declaration.
|
|
bool hasUnresolvedUsing() const { return HasUnresolvedUsing; }
|
|
|
|
/// \brief Determine whether this member expression used the '->'
|
|
/// operator; otherwise, it used the '.' operator.
|
|
bool isArrow() const { return IsArrow; }
|
|
|
|
/// \brief Retrieve the location of the '->' or '.' operator.
|
|
SourceLocation getOperatorLoc() const { return OperatorLoc; }
|
|
|
|
/// \brief Retrieve the naming class of this lookup.
|
|
CXXRecordDecl *getNamingClass() const;
|
|
|
|
/// \brief Retrieve the full name info for the member that this expression
|
|
/// refers to.
|
|
const DeclarationNameInfo &getMemberNameInfo() const { return getNameInfo(); }
|
|
|
|
/// \brief Retrieve the name of the member that this expression
|
|
/// refers to.
|
|
DeclarationName getMemberName() const { return getName(); }
|
|
|
|
// \brief Retrieve the location of the name of the member that this
|
|
// expression refers to.
|
|
SourceLocation getMemberLoc() const { return getNameLoc(); }
|
|
|
|
// \brief Return the preferred location (the member name) for the arrow when
|
|
// diagnosing a problem with this expression.
|
|
SourceLocation getExprLoc() const LLVM_READONLY { return getMemberLoc(); }
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY {
|
|
if (!isImplicitAccess())
|
|
return Base->getLocStart();
|
|
if (NestedNameSpecifierLoc l = getQualifierLoc())
|
|
return l.getBeginLoc();
|
|
return getMemberNameInfo().getLocStart();
|
|
}
|
|
SourceLocation getLocEnd() const LLVM_READONLY {
|
|
if (hasExplicitTemplateArgs())
|
|
return getRAngleLoc();
|
|
return getMemberNameInfo().getLocEnd();
|
|
}
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == UnresolvedMemberExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() {
|
|
if (isImplicitAccess()) return child_range();
|
|
return child_range(&Base, &Base + 1);
|
|
}
|
|
};
|
|
|
|
/// \brief Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
|
|
///
|
|
/// The noexcept expression tests whether a given expression might throw. Its
|
|
/// result is a boolean constant.
|
|
class CXXNoexceptExpr : public Expr {
|
|
bool Value : 1;
|
|
Stmt *Operand;
|
|
SourceRange Range;
|
|
|
|
friend class ASTStmtReader;
|
|
|
|
public:
|
|
CXXNoexceptExpr(QualType Ty, Expr *Operand, CanThrowResult Val,
|
|
SourceLocation Keyword, SourceLocation RParen)
|
|
: Expr(CXXNoexceptExprClass, Ty, VK_RValue, OK_Ordinary,
|
|
/*TypeDependent*/false,
|
|
/*ValueDependent*/Val == CT_Dependent,
|
|
Val == CT_Dependent || Operand->isInstantiationDependent(),
|
|
Operand->containsUnexpandedParameterPack()),
|
|
Value(Val == CT_Cannot), Operand(Operand), Range(Keyword, RParen)
|
|
{ }
|
|
|
|
CXXNoexceptExpr(EmptyShell Empty)
|
|
: Expr(CXXNoexceptExprClass, Empty)
|
|
{ }
|
|
|
|
Expr *getOperand() const { return static_cast<Expr*>(Operand); }
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY { return Range.getBegin(); }
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return Range.getEnd(); }
|
|
SourceRange getSourceRange() const LLVM_READONLY { return Range; }
|
|
|
|
bool getValue() const { return Value; }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXNoexceptExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() { return child_range(&Operand, &Operand + 1); }
|
|
};
|
|
|
|
/// \brief Represents a C++11 pack expansion that produces a sequence of
|
|
/// expressions.
|
|
///
|
|
/// A pack expansion expression contains a pattern (which itself is an
|
|
/// expression) followed by an ellipsis. For example:
|
|
///
|
|
/// \code
|
|
/// template<typename F, typename ...Types>
|
|
/// void forward(F f, Types &&...args) {
|
|
/// f(static_cast<Types&&>(args)...);
|
|
/// }
|
|
/// \endcode
|
|
///
|
|
/// Here, the argument to the function object \c f is a pack expansion whose
|
|
/// pattern is \c static_cast<Types&&>(args). When the \c forward function
|
|
/// template is instantiated, the pack expansion will instantiate to zero or
|
|
/// or more function arguments to the function object \c f.
|
|
class PackExpansionExpr : public Expr {
|
|
SourceLocation EllipsisLoc;
|
|
|
|
/// \brief The number of expansions that will be produced by this pack
|
|
/// expansion expression, if known.
|
|
///
|
|
/// When zero, the number of expansions is not known. Otherwise, this value
|
|
/// is the number of expansions + 1.
|
|
unsigned NumExpansions;
|
|
|
|
Stmt *Pattern;
|
|
|
|
friend class ASTStmtReader;
|
|
friend class ASTStmtWriter;
|
|
|
|
public:
|
|
PackExpansionExpr(QualType T, Expr *Pattern, SourceLocation EllipsisLoc,
|
|
Optional<unsigned> NumExpansions)
|
|
: Expr(PackExpansionExprClass, T, Pattern->getValueKind(),
|
|
Pattern->getObjectKind(), /*TypeDependent=*/true,
|
|
/*ValueDependent=*/true, /*InstantiationDependent=*/true,
|
|
/*ContainsUnexpandedParameterPack=*/false),
|
|
EllipsisLoc(EllipsisLoc),
|
|
NumExpansions(NumExpansions? *NumExpansions + 1 : 0),
|
|
Pattern(Pattern) { }
|
|
|
|
PackExpansionExpr(EmptyShell Empty) : Expr(PackExpansionExprClass, Empty) { }
|
|
|
|
/// \brief Retrieve the pattern of the pack expansion.
|
|
Expr *getPattern() { return reinterpret_cast<Expr *>(Pattern); }
|
|
|
|
/// \brief Retrieve the pattern of the pack expansion.
|
|
const Expr *getPattern() const { return reinterpret_cast<Expr *>(Pattern); }
|
|
|
|
/// \brief Retrieve the location of the ellipsis that describes this pack
|
|
/// expansion.
|
|
SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
|
|
|
|
/// \brief Determine the number of expansions that will be produced when
|
|
/// this pack expansion is instantiated, if already known.
|
|
Optional<unsigned> getNumExpansions() const {
|
|
if (NumExpansions)
|
|
return NumExpansions - 1;
|
|
|
|
return None;
|
|
}
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY {
|
|
return Pattern->getLocStart();
|
|
}
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return EllipsisLoc; }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == PackExpansionExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() {
|
|
return child_range(&Pattern, &Pattern + 1);
|
|
}
|
|
};
|
|
|
|
inline ASTTemplateKWAndArgsInfo *OverloadExpr::getTemplateKWAndArgsInfo() {
|
|
if (!HasTemplateKWAndArgsInfo) return nullptr;
|
|
if (isa<UnresolvedLookupExpr>(this))
|
|
return reinterpret_cast<ASTTemplateKWAndArgsInfo*>
|
|
(cast<UnresolvedLookupExpr>(this) + 1);
|
|
else
|
|
return reinterpret_cast<ASTTemplateKWAndArgsInfo*>
|
|
(cast<UnresolvedMemberExpr>(this) + 1);
|
|
}
|
|
|
|
/// \brief Represents an expression that computes the length of a parameter
|
|
/// pack.
|
|
///
|
|
/// \code
|
|
/// template<typename ...Types>
|
|
/// struct count {
|
|
/// static const unsigned value = sizeof...(Types);
|
|
/// };
|
|
/// \endcode
|
|
class SizeOfPackExpr : public Expr {
|
|
/// \brief The location of the \c sizeof keyword.
|
|
SourceLocation OperatorLoc;
|
|
|
|
/// \brief The location of the name of the parameter pack.
|
|
SourceLocation PackLoc;
|
|
|
|
/// \brief The location of the closing parenthesis.
|
|
SourceLocation RParenLoc;
|
|
|
|
/// \brief The length of the parameter pack, if known.
|
|
///
|
|
/// When this expression is value-dependent, the length of the parameter pack
|
|
/// is unknown. When this expression is not value-dependent, the length is
|
|
/// known.
|
|
unsigned Length;
|
|
|
|
/// \brief The parameter pack itself.
|
|
NamedDecl *Pack;
|
|
|
|
friend class ASTStmtReader;
|
|
friend class ASTStmtWriter;
|
|
|
|
public:
|
|
/// \brief Create a value-dependent expression that computes the length of
|
|
/// the given parameter pack.
|
|
SizeOfPackExpr(QualType SizeType, SourceLocation OperatorLoc, NamedDecl *Pack,
|
|
SourceLocation PackLoc, SourceLocation RParenLoc)
|
|
: Expr(SizeOfPackExprClass, SizeType, VK_RValue, OK_Ordinary,
|
|
/*TypeDependent=*/false, /*ValueDependent=*/true,
|
|
/*InstantiationDependent=*/true,
|
|
/*ContainsUnexpandedParameterPack=*/false),
|
|
OperatorLoc(OperatorLoc), PackLoc(PackLoc), RParenLoc(RParenLoc),
|
|
Length(0), Pack(Pack) { }
|
|
|
|
/// \brief Create an expression that computes the length of
|
|
/// the given parameter pack, which is already known.
|
|
SizeOfPackExpr(QualType SizeType, SourceLocation OperatorLoc, NamedDecl *Pack,
|
|
SourceLocation PackLoc, SourceLocation RParenLoc,
|
|
unsigned Length)
|
|
: Expr(SizeOfPackExprClass, SizeType, VK_RValue, OK_Ordinary,
|
|
/*TypeDependent=*/false, /*ValueDependent=*/false,
|
|
/*InstantiationDependent=*/false,
|
|
/*ContainsUnexpandedParameterPack=*/false),
|
|
OperatorLoc(OperatorLoc), PackLoc(PackLoc), RParenLoc(RParenLoc),
|
|
Length(Length), Pack(Pack) { }
|
|
|
|
/// \brief Create an empty expression.
|
|
SizeOfPackExpr(EmptyShell Empty) : Expr(SizeOfPackExprClass, Empty) { }
|
|
|
|
/// \brief Determine the location of the 'sizeof' keyword.
|
|
SourceLocation getOperatorLoc() const { return OperatorLoc; }
|
|
|
|
/// \brief Determine the location of the parameter pack.
|
|
SourceLocation getPackLoc() const { return PackLoc; }
|
|
|
|
/// \brief Determine the location of the right parenthesis.
|
|
SourceLocation getRParenLoc() const { return RParenLoc; }
|
|
|
|
/// \brief Retrieve the parameter pack.
|
|
NamedDecl *getPack() const { return Pack; }
|
|
|
|
/// \brief Retrieve the length of the parameter pack.
|
|
///
|
|
/// This routine may only be invoked when the expression is not
|
|
/// value-dependent.
|
|
unsigned getPackLength() const {
|
|
assert(!isValueDependent() &&
|
|
"Cannot get the length of a value-dependent pack size expression");
|
|
return Length;
|
|
}
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY { return OperatorLoc; }
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return RParenLoc; }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == SizeOfPackExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() { return child_range(); }
|
|
};
|
|
|
|
/// \brief Represents a reference to a non-type template parameter
|
|
/// that has been substituted with a template argument.
|
|
class SubstNonTypeTemplateParmExpr : public Expr {
|
|
/// \brief The replaced parameter.
|
|
NonTypeTemplateParmDecl *Param;
|
|
|
|
/// \brief The replacement expression.
|
|
Stmt *Replacement;
|
|
|
|
/// \brief The location of the non-type template parameter reference.
|
|
SourceLocation NameLoc;
|
|
|
|
friend class ASTReader;
|
|
friend class ASTStmtReader;
|
|
explicit SubstNonTypeTemplateParmExpr(EmptyShell Empty)
|
|
: Expr(SubstNonTypeTemplateParmExprClass, Empty) { }
|
|
|
|
public:
|
|
SubstNonTypeTemplateParmExpr(QualType type,
|
|
ExprValueKind valueKind,
|
|
SourceLocation loc,
|
|
NonTypeTemplateParmDecl *param,
|
|
Expr *replacement)
|
|
: Expr(SubstNonTypeTemplateParmExprClass, type, valueKind, OK_Ordinary,
|
|
replacement->isTypeDependent(), replacement->isValueDependent(),
|
|
replacement->isInstantiationDependent(),
|
|
replacement->containsUnexpandedParameterPack()),
|
|
Param(param), Replacement(replacement), NameLoc(loc) {}
|
|
|
|
SourceLocation getNameLoc() const { return NameLoc; }
|
|
SourceLocation getLocStart() const LLVM_READONLY { return NameLoc; }
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return NameLoc; }
|
|
|
|
Expr *getReplacement() const { return cast<Expr>(Replacement); }
|
|
|
|
NonTypeTemplateParmDecl *getParameter() const { return Param; }
|
|
|
|
static bool classof(const Stmt *s) {
|
|
return s->getStmtClass() == SubstNonTypeTemplateParmExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() { return child_range(&Replacement, &Replacement+1); }
|
|
};
|
|
|
|
/// \brief Represents a reference to a non-type template parameter pack that
|
|
/// has been substituted with a non-template argument pack.
|
|
///
|
|
/// When a pack expansion in the source code contains multiple parameter packs
|
|
/// and those parameter packs correspond to different levels of template
|
|
/// parameter lists, this node is used to represent a non-type template
|
|
/// parameter pack from an outer level, which has already had its argument pack
|
|
/// substituted but that still lives within a pack expansion that itself
|
|
/// could not be instantiated. When actually performing a substitution into
|
|
/// that pack expansion (e.g., when all template parameters have corresponding
|
|
/// arguments), this type will be replaced with the appropriate underlying
|
|
/// expression at the current pack substitution index.
|
|
class SubstNonTypeTemplateParmPackExpr : public Expr {
|
|
/// \brief The non-type template parameter pack itself.
|
|
NonTypeTemplateParmDecl *Param;
|
|
|
|
/// \brief A pointer to the set of template arguments that this
|
|
/// parameter pack is instantiated with.
|
|
const TemplateArgument *Arguments;
|
|
|
|
/// \brief The number of template arguments in \c Arguments.
|
|
unsigned NumArguments;
|
|
|
|
/// \brief The location of the non-type template parameter pack reference.
|
|
SourceLocation NameLoc;
|
|
|
|
friend class ASTReader;
|
|
friend class ASTStmtReader;
|
|
explicit SubstNonTypeTemplateParmPackExpr(EmptyShell Empty)
|
|
: Expr(SubstNonTypeTemplateParmPackExprClass, Empty) { }
|
|
|
|
public:
|
|
SubstNonTypeTemplateParmPackExpr(QualType T,
|
|
NonTypeTemplateParmDecl *Param,
|
|
SourceLocation NameLoc,
|
|
const TemplateArgument &ArgPack);
|
|
|
|
/// \brief Retrieve the non-type template parameter pack being substituted.
|
|
NonTypeTemplateParmDecl *getParameterPack() const { return Param; }
|
|
|
|
/// \brief Retrieve the location of the parameter pack name.
|
|
SourceLocation getParameterPackLocation() const { return NameLoc; }
|
|
|
|
/// \brief Retrieve the template argument pack containing the substituted
|
|
/// template arguments.
|
|
TemplateArgument getArgumentPack() const;
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY { return NameLoc; }
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return NameLoc; }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == SubstNonTypeTemplateParmPackExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() { return child_range(); }
|
|
};
|
|
|
|
/// \brief Represents a reference to a function parameter pack that has been
|
|
/// substituted but not yet expanded.
|
|
///
|
|
/// When a pack expansion contains multiple parameter packs at different levels,
|
|
/// this node is used to represent a function parameter pack at an outer level
|
|
/// which we have already substituted to refer to expanded parameters, but where
|
|
/// the containing pack expansion cannot yet be expanded.
|
|
///
|
|
/// \code
|
|
/// template<typename...Ts> struct S {
|
|
/// template<typename...Us> auto f(Ts ...ts) -> decltype(g(Us(ts)...));
|
|
/// };
|
|
/// template struct S<int, int>;
|
|
/// \endcode
|
|
class FunctionParmPackExpr : public Expr {
|
|
/// \brief The function parameter pack which was referenced.
|
|
ParmVarDecl *ParamPack;
|
|
|
|
/// \brief The location of the function parameter pack reference.
|
|
SourceLocation NameLoc;
|
|
|
|
/// \brief The number of expansions of this pack.
|
|
unsigned NumParameters;
|
|
|
|
FunctionParmPackExpr(QualType T, ParmVarDecl *ParamPack,
|
|
SourceLocation NameLoc, unsigned NumParams,
|
|
Decl * const *Params);
|
|
|
|
friend class ASTReader;
|
|
friend class ASTStmtReader;
|
|
|
|
public:
|
|
static FunctionParmPackExpr *Create(const ASTContext &Context, QualType T,
|
|
ParmVarDecl *ParamPack,
|
|
SourceLocation NameLoc,
|
|
ArrayRef<Decl *> Params);
|
|
static FunctionParmPackExpr *CreateEmpty(const ASTContext &Context,
|
|
unsigned NumParams);
|
|
|
|
/// \brief Get the parameter pack which this expression refers to.
|
|
ParmVarDecl *getParameterPack() const { return ParamPack; }
|
|
|
|
/// \brief Get the location of the parameter pack.
|
|
SourceLocation getParameterPackLocation() const { return NameLoc; }
|
|
|
|
/// \brief Iterators over the parameters which the parameter pack expanded
|
|
/// into.
|
|
typedef ParmVarDecl * const *iterator;
|
|
iterator begin() const { return reinterpret_cast<iterator>(this+1); }
|
|
iterator end() const { return begin() + NumParameters; }
|
|
|
|
/// \brief Get the number of parameters in this parameter pack.
|
|
unsigned getNumExpansions() const { return NumParameters; }
|
|
|
|
/// \brief Get an expansion of the parameter pack by index.
|
|
ParmVarDecl *getExpansion(unsigned I) const { return begin()[I]; }
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY { return NameLoc; }
|
|
SourceLocation getLocEnd() const LLVM_READONLY { return NameLoc; }
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == FunctionParmPackExprClass;
|
|
}
|
|
|
|
child_range children() { return child_range(); }
|
|
};
|
|
|
|
/// \brief Represents a prvalue temporary that is written into memory so that
|
|
/// a reference can bind to it.
|
|
///
|
|
/// Prvalue expressions are materialized when they need to have an address
|
|
/// in memory for a reference to bind to. This happens when binding a
|
|
/// reference to the result of a conversion, e.g.,
|
|
///
|
|
/// \code
|
|
/// const int &r = 1.0;
|
|
/// \endcode
|
|
///
|
|
/// Here, 1.0 is implicitly converted to an \c int. That resulting \c int is
|
|
/// then materialized via a \c MaterializeTemporaryExpr, and the reference
|
|
/// binds to the temporary. \c MaterializeTemporaryExprs are always glvalues
|
|
/// (either an lvalue or an xvalue, depending on the kind of reference binding
|
|
/// to it), maintaining the invariant that references always bind to glvalues.
|
|
///
|
|
/// Reference binding and copy-elision can both extend the lifetime of a
|
|
/// temporary. When either happens, the expression will also track the
|
|
/// declaration which is responsible for the lifetime extension.
|
|
class MaterializeTemporaryExpr : public Expr {
|
|
private:
|
|
struct ExtraState {
|
|
/// \brief The temporary-generating expression whose value will be
|
|
/// materialized.
|
|
Stmt *Temporary;
|
|
|
|
/// \brief The declaration which lifetime-extended this reference, if any.
|
|
/// Either a VarDecl, or (for a ctor-initializer) a FieldDecl.
|
|
const ValueDecl *ExtendingDecl;
|
|
|
|
unsigned ManglingNumber;
|
|
};
|
|
llvm::PointerUnion<Stmt *, ExtraState *> State;
|
|
|
|
friend class ASTStmtReader;
|
|
friend class ASTStmtWriter;
|
|
|
|
void initializeExtraState(const ValueDecl *ExtendedBy,
|
|
unsigned ManglingNumber);
|
|
|
|
public:
|
|
MaterializeTemporaryExpr(QualType T, Expr *Temporary,
|
|
bool BoundToLvalueReference)
|
|
: Expr(MaterializeTemporaryExprClass, T,
|
|
BoundToLvalueReference? VK_LValue : VK_XValue, OK_Ordinary,
|
|
Temporary->isTypeDependent(), Temporary->isValueDependent(),
|
|
Temporary->isInstantiationDependent(),
|
|
Temporary->containsUnexpandedParameterPack()),
|
|
State(Temporary) {}
|
|
|
|
MaterializeTemporaryExpr(EmptyShell Empty)
|
|
: Expr(MaterializeTemporaryExprClass, Empty) { }
|
|
|
|
Stmt *getTemporary() const {
|
|
return State.is<Stmt *>() ? State.get<Stmt *>()
|
|
: State.get<ExtraState *>()->Temporary;
|
|
}
|
|
|
|
/// \brief Retrieve the temporary-generating subexpression whose value will
|
|
/// be materialized into a glvalue.
|
|
Expr *GetTemporaryExpr() const { return static_cast<Expr *>(getTemporary()); }
|
|
|
|
/// \brief Retrieve the storage duration for the materialized temporary.
|
|
StorageDuration getStorageDuration() const {
|
|
const ValueDecl *ExtendingDecl = getExtendingDecl();
|
|
if (!ExtendingDecl)
|
|
return SD_FullExpression;
|
|
// FIXME: This is not necessarily correct for a temporary materialized
|
|
// within a default initializer.
|
|
if (isa<FieldDecl>(ExtendingDecl))
|
|
return SD_Automatic;
|
|
return cast<VarDecl>(ExtendingDecl)->getStorageDuration();
|
|
}
|
|
|
|
/// \brief Get the declaration which triggered the lifetime-extension of this
|
|
/// temporary, if any.
|
|
const ValueDecl *getExtendingDecl() const {
|
|
return State.is<Stmt *>() ? nullptr
|
|
: State.get<ExtraState *>()->ExtendingDecl;
|
|
}
|
|
|
|
void setExtendingDecl(const ValueDecl *ExtendedBy, unsigned ManglingNumber);
|
|
|
|
unsigned getManglingNumber() const {
|
|
return State.is<Stmt *>() ? 0 : State.get<ExtraState *>()->ManglingNumber;
|
|
}
|
|
|
|
/// \brief Determine whether this materialized temporary is bound to an
|
|
/// lvalue reference; otherwise, it's bound to an rvalue reference.
|
|
bool isBoundToLvalueReference() const {
|
|
return getValueKind() == VK_LValue;
|
|
}
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY {
|
|
return getTemporary()->getLocStart();
|
|
}
|
|
SourceLocation getLocEnd() const LLVM_READONLY {
|
|
return getTemporary()->getLocEnd();
|
|
}
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == MaterializeTemporaryExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() {
|
|
if (State.is<Stmt *>())
|
|
return child_range(State.getAddrOfPtr1(), State.getAddrOfPtr1() + 1);
|
|
|
|
auto ES = State.get<ExtraState *>();
|
|
return child_range(&ES->Temporary, &ES->Temporary + 1);
|
|
}
|
|
};
|
|
|
|
/// \brief Represents a folding of a pack over an operator.
|
|
///
|
|
/// This expression is always dependent and represents a pack expansion of the
|
|
/// forms:
|
|
///
|
|
/// ( expr op ... )
|
|
/// ( ... op expr )
|
|
/// ( expr op ... op expr )
|
|
class CXXFoldExpr : public Expr {
|
|
SourceLocation LParenLoc;
|
|
SourceLocation EllipsisLoc;
|
|
SourceLocation RParenLoc;
|
|
Stmt *SubExprs[2];
|
|
BinaryOperatorKind Opcode;
|
|
|
|
friend class ASTStmtReader;
|
|
friend class ASTStmtWriter;
|
|
public:
|
|
CXXFoldExpr(QualType T, SourceLocation LParenLoc, Expr *LHS,
|
|
BinaryOperatorKind Opcode, SourceLocation EllipsisLoc, Expr *RHS,
|
|
SourceLocation RParenLoc)
|
|
: Expr(CXXFoldExprClass, T, VK_RValue, OK_Ordinary,
|
|
/*Dependent*/ true, true, true,
|
|
/*ContainsUnexpandedParameterPack*/ false),
|
|
LParenLoc(LParenLoc), EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc),
|
|
Opcode(Opcode) {
|
|
SubExprs[0] = LHS;
|
|
SubExprs[1] = RHS;
|
|
}
|
|
CXXFoldExpr(EmptyShell Empty) : Expr(CXXFoldExprClass, Empty) {}
|
|
|
|
Expr *getLHS() const { return static_cast<Expr*>(SubExprs[0]); }
|
|
Expr *getRHS() const { return static_cast<Expr*>(SubExprs[1]); }
|
|
|
|
/// Does this produce a right-associated sequence of operators?
|
|
bool isRightFold() const {
|
|
return getLHS() && getLHS()->containsUnexpandedParameterPack();
|
|
}
|
|
/// Does this produce a left-associated sequence of operators?
|
|
bool isLeftFold() const { return !isRightFold(); }
|
|
/// Get the pattern, that is, the operand that contains an unexpanded pack.
|
|
Expr *getPattern() const { return isLeftFold() ? getRHS() : getLHS(); }
|
|
/// Get the operand that doesn't contain a pack, for a binary fold.
|
|
Expr *getInit() const { return isLeftFold() ? getLHS() : getRHS(); }
|
|
|
|
SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
|
|
BinaryOperatorKind getOperator() const { return Opcode; }
|
|
|
|
SourceLocation getLocStart() const LLVM_READONLY {
|
|
return LParenLoc;
|
|
}
|
|
SourceLocation getLocEnd() const LLVM_READONLY {
|
|
return RParenLoc;
|
|
}
|
|
|
|
static bool classof(const Stmt *T) {
|
|
return T->getStmtClass() == CXXFoldExprClass;
|
|
}
|
|
|
|
// Iterators
|
|
child_range children() { return child_range(SubExprs, SubExprs + 2); }
|
|
};
|
|
|
|
} // end namespace clang
|
|
|
|
#endif
|