20#include "llvm/Support/ErrorHandling.h"
33 const Expr *falseExpr);
38 assert(!TR->
isReferenceType() &&
"Expressions can't have reference type.");
79 return Classification(kind, modifiable);
105 llvm_unreachable(
"Invalid value category of implicit cast.");
114#define ABSTRACT_STMT(Kind)
115#define STMT(Kind, Base) case Expr::Kind##Class:
116#define EXPR(Kind, Base)
117#include "clang/AST/StmtNodes.inc"
118 llvm_unreachable(
"cannot classify a statement");
121 case Expr::ObjCIsaExprClass:
123 case Expr::StringLiteralClass:
125 case Expr::ObjCEncodeExprClass:
127 case Expr::PredefinedExprClass:
129 case Expr::ObjCSubscriptRefExprClass:
130 case Expr::ObjCPropertyRefExprClass:
132 case Expr::CXXTypeidExprClass:
133 case Expr::CXXUuidofExprClass:
136 case Expr::UnresolvedLookupExprClass:
137 case Expr::UnresolvedMemberExprClass:
138 case Expr::TypoExprClass:
139 case Expr::DependentCoawaitExprClass:
140 case Expr::CXXDependentScopeMemberExprClass:
141 case Expr::DependentScopeDeclRefExprClass:
144 case Expr::ObjCIvarRefExprClass:
145 case Expr::FunctionParmPackExprClass:
146 case Expr::MSPropertyRefExprClass:
147 case Expr::MSPropertySubscriptExprClass:
148 case Expr::OMPArraySectionExprClass:
149 case Expr::OMPArrayShapingExprClass:
150 case Expr::OMPIteratorExprClass:
155 case Expr::CompoundLiteralExprClass:
159 case Expr::CXXBoolLiteralExprClass:
160 case Expr::CXXPseudoDestructorExprClass:
161 case Expr::UnaryExprOrTypeTraitExprClass:
162 case Expr::CXXNewExprClass:
163 case Expr::CXXNullPtrLiteralExprClass:
164 case Expr::ImaginaryLiteralClass:
165 case Expr::GNUNullExprClass:
166 case Expr::OffsetOfExprClass:
167 case Expr::CXXThrowExprClass:
168 case Expr::ShuffleVectorExprClass:
169 case Expr::ConvertVectorExprClass:
170 case Expr::IntegerLiteralClass:
171 case Expr::FixedPointLiteralClass:
172 case Expr::CharacterLiteralClass:
173 case Expr::AddrLabelExprClass:
174 case Expr::CXXDeleteExprClass:
175 case Expr::ImplicitValueInitExprClass:
176 case Expr::BlockExprClass:
177 case Expr::FloatingLiteralClass:
178 case Expr::CXXNoexceptExprClass:
179 case Expr::CXXScalarValueInitExprClass:
180 case Expr::TypeTraitExprClass:
181 case Expr::ArrayTypeTraitExprClass:
182 case Expr::ExpressionTraitExprClass:
183 case Expr::ObjCSelectorExprClass:
184 case Expr::ObjCProtocolExprClass:
185 case Expr::ObjCStringLiteralClass:
186 case Expr::ObjCBoxedExprClass:
187 case Expr::ObjCArrayLiteralClass:
188 case Expr::ObjCDictionaryLiteralClass:
189 case Expr::ObjCBoolLiteralExprClass:
190 case Expr::ObjCAvailabilityCheckExprClass:
191 case Expr::ParenListExprClass:
192 case Expr::SizeOfPackExprClass:
193 case Expr::SubstNonTypeTemplateParmPackExprClass:
194 case Expr::AsTypeExprClass:
195 case Expr::ObjCIndirectCopyRestoreExprClass:
196 case Expr::AtomicExprClass:
197 case Expr::CXXFoldExprClass:
198 case Expr::ArrayInitLoopExprClass:
199 case Expr::ArrayInitIndexExprClass:
200 case Expr::NoInitExprClass:
201 case Expr::DesignatedInitUpdateExprClass:
202 case Expr::SourceLocExprClass:
203 case Expr::ConceptSpecializationExprClass:
204 case Expr::RequiresExprClass:
208 case Expr::CXXThisExprClass:
211 case Expr::ConstantExprClass:
215 case Expr::SubstNonTypeTemplateParmExprClass:
217 cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement());
223 case Expr::ArraySubscriptExprClass:
224 if (cast<ArraySubscriptExpr>(E)->getBase()->getType()->isVectorType())
226 if (Lang.CPlusPlus11) {
229 auto *
Base = cast<ArraySubscriptExpr>(E)->getBase()->IgnoreImpCasts();
230 if (
Base->getType()->isArrayType())
236 case Expr::MatrixSubscriptExprClass:
241 case Expr::DeclRefExprClass:
243 return isa<FunctionDecl>(cast<DeclRefExpr>(E)->getDecl())
245 return ClassifyDecl(Ctx, cast<DeclRefExpr>(E)->getDecl());
248 case Expr::MemberExprClass:
251 case Expr::UnaryOperatorClass:
252 switch (cast<UnaryOperator>(E)->getOpcode()) {
271 if (isa<ObjCPropertyRefExpr>(Op))
287 case Expr::RecoveryExprClass:
288 case Expr::OpaqueValueExprClass:
292 case Expr::PseudoObjectExprClass:
294 cast<PseudoObjectExpr>(E)->getValueKind());
298 case Expr::ImplicitCastExprClass:
303 case Expr::ParenExprClass:
309 case Expr::GenericSelectionExprClass:
310 if (cast<GenericSelectionExpr>(E)->isResultDependent())
312 return ClassifyInternal(Ctx,cast<GenericSelectionExpr>(E)->getResultExpr());
314 case Expr::BinaryOperatorClass:
315 case Expr::CompoundAssignOperatorClass:
321 case Expr::CallExprClass:
322 case Expr::CXXOperatorCallExprClass:
323 case Expr::CXXMemberCallExprClass:
324 case Expr::UserDefinedLiteralClass:
325 case Expr::CUDAKernelCallExprClass:
326 return ClassifyUnnamed(Ctx, cast<CallExpr>(E)->getCallReturnType(Ctx));
328 case Expr::CXXRewrittenBinaryOperatorClass:
330 Ctx, cast<CXXRewrittenBinaryOperator>(E)->getSemanticForm());
333 case Expr::ChooseExprClass:
338 case Expr::ExtVectorElementExprClass:
339 if (cast<ExtVectorElementExpr>(E)->containsDuplicateElements())
341 if (cast<ExtVectorElementExpr>(E)->isArrow())
346 case Expr::CXXDefaultArgExprClass:
350 case Expr::CXXDefaultInitExprClass:
354 case Expr::CXXBindTemporaryExprClass:
358 case Expr::ExprWithCleanupsClass:
362 case Expr::CStyleCastExprClass:
363 case Expr::CXXFunctionalCastExprClass:
364 case Expr::CXXStaticCastExprClass:
365 case Expr::CXXDynamicCastExprClass:
366 case Expr::CXXReinterpretCastExprClass:
367 case Expr::CXXConstCastExprClass:
368 case Expr::CXXAddrspaceCastExprClass:
369 case Expr::ObjCBridgedCastExprClass:
370 case Expr::BuiltinBitCastExprClass:
373 return ClassifyUnnamed(Ctx, cast<ExplicitCastExpr>(E)->getTypeAsWritten());
375 case Expr::CXXUnresolvedConstructExprClass:
377 cast<CXXUnresolvedConstructExpr>(E)->getTypeAsWritten());
379 case Expr::BinaryConditionalOperatorClass: {
381 const auto *co = cast<BinaryConditionalOperator>(E);
385 case Expr::ConditionalOperatorClass: {
388 const auto *co = cast<ConditionalOperator>(E);
394 case Expr::ObjCMessageExprClass:
396 cast<ObjCMessageExpr>(E)->getMethodDecl()) {
403 case Expr::CXXConstructExprClass:
404 case Expr::CXXInheritedCtorInitExprClass:
405 case Expr::CXXTemporaryObjectExprClass:
406 case Expr::LambdaExprClass:
407 case Expr::CXXStdInitializerListExprClass:
410 case Expr::VAArgExprClass:
413 case Expr::DesignatedInitExprClass:
416 case Expr::StmtExprClass: {
417 const CompoundStmt *S = cast<StmtExpr>(E)->getSubStmt();
418 if (
const auto *LastExpr = dyn_cast_or_null<Expr>(S->body_back()))
423 case Expr::PackExpansionExprClass:
426 case Expr::MaterializeTemporaryExprClass:
427 return cast<MaterializeTemporaryExpr>(E)->isBoundToLvalueReference()
431 case Expr::InitListExprClass:
438 assert(cast<InitListExpr>(E)->getNumInits() == 1 &&
439 "Only 1-element init lists can be glvalues.");
442 case Expr::CoawaitExprClass:
443 case Expr::CoyieldExprClass:
444 return ClassifyInternal(Ctx, cast<CoroutineSuspendExpr>(E)->getResumeExpr());
445 case Expr::SYCLUniqueStableNameExprClass:
449 case Expr::CXXParenListInitExprClass:
450 if (isa<ArrayType>(E->
getType()))
455 llvm_unreachable(
"unhandled expression kind in classification");
468 if (isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance())
472 if (
const auto *NTTParm = dyn_cast<NonTypeTemplateParmDecl>(D))
473 islvalue = NTTParm->getType()->isReferenceType() ||
474 NTTParm->getType()->isRecordType();
480 (isa<FunctionDecl, MSPropertyDecl, FunctionTemplateDecl>(D)));
519 if (isa<ObjCPropertyRefExpr>(
Base))
528 if (
const auto *
Value = dyn_cast<ValueDecl>(
Member))
534 if (isa<VarDecl>(
Member) &&
Member->getDeclContext()->isRecord())
540 if (isa<FieldDecl>(
Member)) {
545 if (isa<ObjCPropertyRefExpr>(
Base))
554 if (
const auto *Method = dyn_cast<CXXMethodDecl>(
Member))
564 "This is only relevant for C++.");
600 "This is only relevant for C++.");
611 if (
const Expr *NonThrow = TrueIsThrow ? (FalseIsThrow ?
nullptr : False)
612 : (FalseIsThrow ? True :
nullptr))
636 if (
const auto *CE = dyn_cast<ExplicitCastExpr>(E->
IgnoreParens())) {
637 if (CE->getSubExpr()->IgnoreParenImpCasts()->isLValue()) {
638 Loc = CE->getExprLoc();
653 if (
const auto *
Expr = dyn_cast<ObjCPropertyRefExpr>(E)) {
654 if (
Expr->isImplicitProperty() &&
655 Expr->getImplicitPropertySetter() ==
nullptr)
668 if (CT->isArrayType())
671 if (CT->isIncompleteType())
676 if (R->hasConstFields())
698 llvm_unreachable(
"Unhandled kind");
725 case Cl::CM_RValue: llvm_unreachable(
"CM_RValue and CL_LValue don't match");
728 llvm_unreachable(
"CM_LValueCast and CL_LValue don't match");
736 llvm_unreachable(
"Unhandled modifiable type");
Defines the clang::ASTContext interface.
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
Defines the clang::Expr interface and subclasses for C++ expressions.
static Cl::Kinds ClassifyUnnamed(ASTContext &Ctx, QualType T)
ClassifyUnnamed - Return the classification of an expression yielding an unnamed value of the given t...
static Cl::Kinds ClassifyConditional(ASTContext &Ctx, const Expr *trueExpr, const Expr *falseExpr)
static Cl::Kinds ClassifyDecl(ASTContext &Ctx, const Decl *D)
ClassifyDecl - Return the classification of an expression referencing the given declaration.
static Cl::Kinds ClassifyMemberExpr(ASTContext &Ctx, const MemberExpr *E)
static Cl::Kinds ClassifyInternal(ASTContext &Ctx, const Expr *E)
static Cl::Kinds ClassifyExprValueKind(const LangOptions &Lang, const Expr *E, ExprValueKind Kind)
static Cl::ModifiableType IsModifiable(ASTContext &Ctx, const Expr *E, Cl::Kinds Kind, SourceLocation &Loc)
static Cl::Kinds ClassifyTemporary(QualType T)
Classify an expression which creates a temporary, based on its type.
static Cl::Kinds ClassifyBinaryOp(ASTContext &Ctx, const BinaryOperator *E)
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
const LangOptions & getLangOpts() const
A builtin binary operation expression such as "x + y" or "x <= y".
static bool isAssignmentOp(Opcode Opc)
A binding in a decomposition declaration.
bool isConstQualified() const
Qualifiers getQualifiers() const
Retrieve all qualifiers.
CanProxy< U > getAs() const
Retrieve a canonical type pointer with a different static type, upcasting or downcasting as needed.
CompoundStmt - This represents a group of statements like { stmt stmt }.
Decl - This represents one declaration (or definition), e.g.
The return type of classify().
ModifiableType
The results of modification testing.
ModifiableType getModifiable() const
Kinds
The various classification results. Most of these mean prvalue.
@ CL_SubObjCPropertySetting
@ CL_DuplicateVectorComponents
This represents one expression.
@ LV_DuplicateVectorComponents
@ LV_InvalidMessageExpression
@ LV_SubObjCPropertySetting
Classification ClassifyModifiable(ASTContext &Ctx, SourceLocation &Loc) const
ClassifyModifiable - Classify this expression according to the C++11 expression taxonomy,...
isModifiableLvalueResult isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, does not have an incomplet...
LValueClassification ClassifyLValue(ASTContext &Ctx) const
Reasons why an expression might not be an l-value.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
@ MLV_DuplicateVectorComponents
@ MLV_InvalidMessageExpression
@ MLV_ConstQualifiedField
@ MLV_SubObjCPropertySetting
Classification Classify(ASTContext &Ctx) const
Classify - Classify this expression according to the C++11 expression taxonomy.
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
Represents a member of a struct/union/class.
Represents a field injected from an anonymous union/struct into the parent scope.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
This represents a decl that may have a name.
ObjCMethodDecl - Represents an instance or class method declaration.
A (possibly-)qualified type.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
LangAS getAddressSpace() const
An rvalue reference type, per C++11 [dcl.ref].
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Encodes a location in the source.
StmtClass getStmtClass() const
A template parameter object.
bool isReferenceType() const
bool isLValueReferenceType() const
bool isFunctionType() const
const T * getAs() const
Member-template getAs<specific type>'.
bool isRecordType() const
An artificial decl, representing a global anonymous constant value which is uniquified by value withi...
Represents a variable declaration or definition.
bool isa(CodeGen::Address addr)
@ OK_ObjCProperty
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_XValue
An x-value expression is a reference to an object with independent storage but which can be "moved",...
@ VK_LValue
An l-value expression is a reference to an object with independent storage.