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::ArraySectionExprClass:
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());
219 case Expr::PackIndexingExprClass: {
222 if (cast<PackIndexingExpr>(E)->isInstantiationDependent())
231 case Expr::ArraySubscriptExprClass:
232 if (cast<ArraySubscriptExpr>(E)->getBase()->getType()->isVectorType())
234 if (Lang.CPlusPlus11) {
237 auto *
Base = cast<ArraySubscriptExpr>(E)->getBase()->IgnoreImpCasts();
238 if (
Base->getType()->isArrayType())
244 case Expr::MatrixSubscriptExprClass:
249 case Expr::DeclRefExprClass:
251 return isa<FunctionDecl>(cast<DeclRefExpr>(E)->getDecl())
253 return ClassifyDecl(Ctx, cast<DeclRefExpr>(E)->getDecl());
256 case Expr::MemberExprClass:
259 case Expr::UnaryOperatorClass:
260 switch (cast<UnaryOperator>(E)->getOpcode()) {
279 if (isa<ObjCPropertyRefExpr>(Op))
295 case Expr::RecoveryExprClass:
296 case Expr::OpaqueValueExprClass:
300 case Expr::PseudoObjectExprClass:
302 cast<PseudoObjectExpr>(E)->getValueKind());
306 case Expr::ImplicitCastExprClass:
311 case Expr::ParenExprClass:
317 case Expr::GenericSelectionExprClass:
318 if (cast<GenericSelectionExpr>(E)->isResultDependent())
320 return ClassifyInternal(Ctx,cast<GenericSelectionExpr>(E)->getResultExpr());
322 case Expr::BinaryOperatorClass:
323 case Expr::CompoundAssignOperatorClass:
329 case Expr::CallExprClass:
330 case Expr::CXXOperatorCallExprClass:
331 case Expr::CXXMemberCallExprClass:
332 case Expr::UserDefinedLiteralClass:
333 case Expr::CUDAKernelCallExprClass:
334 return ClassifyUnnamed(Ctx, cast<CallExpr>(E)->getCallReturnType(Ctx));
336 case Expr::CXXRewrittenBinaryOperatorClass:
338 Ctx, cast<CXXRewrittenBinaryOperator>(E)->getSemanticForm());
341 case Expr::ChooseExprClass:
346 case Expr::ExtVectorElementExprClass:
347 if (cast<ExtVectorElementExpr>(E)->containsDuplicateElements())
349 if (cast<ExtVectorElementExpr>(E)->isArrow())
354 case Expr::CXXDefaultArgExprClass:
358 case Expr::CXXDefaultInitExprClass:
362 case Expr::CXXBindTemporaryExprClass:
366 case Expr::ExprWithCleanupsClass:
370 case Expr::CStyleCastExprClass:
371 case Expr::CXXFunctionalCastExprClass:
372 case Expr::CXXStaticCastExprClass:
373 case Expr::CXXDynamicCastExprClass:
374 case Expr::CXXReinterpretCastExprClass:
375 case Expr::CXXConstCastExprClass:
376 case Expr::CXXAddrspaceCastExprClass:
377 case Expr::ObjCBridgedCastExprClass:
378 case Expr::BuiltinBitCastExprClass:
381 return ClassifyUnnamed(Ctx, cast<ExplicitCastExpr>(E)->getTypeAsWritten());
383 case Expr::CXXUnresolvedConstructExprClass:
385 cast<CXXUnresolvedConstructExpr>(E)->getTypeAsWritten());
387 case Expr::BinaryConditionalOperatorClass: {
389 const auto *co = cast<BinaryConditionalOperator>(E);
393 case Expr::ConditionalOperatorClass: {
396 const auto *co = cast<ConditionalOperator>(E);
402 case Expr::ObjCMessageExprClass:
404 cast<ObjCMessageExpr>(E)->getMethodDecl()) {
411 case Expr::CXXConstructExprClass:
412 case Expr::CXXInheritedCtorInitExprClass:
413 case Expr::CXXTemporaryObjectExprClass:
414 case Expr::LambdaExprClass:
415 case Expr::CXXStdInitializerListExprClass:
418 case Expr::VAArgExprClass:
421 case Expr::DesignatedInitExprClass:
424 case Expr::StmtExprClass: {
425 const CompoundStmt *S = cast<StmtExpr>(E)->getSubStmt();
426 if (
const auto *LastExpr = dyn_cast_or_null<Expr>(S->body_back()))
431 case Expr::PackExpansionExprClass:
434 case Expr::MaterializeTemporaryExprClass:
435 return cast<MaterializeTemporaryExpr>(E)->isBoundToLvalueReference()
439 case Expr::InitListExprClass:
446 assert(cast<InitListExpr>(E)->getNumInits() == 1 &&
447 "Only 1-element init lists can be glvalues.");
450 case Expr::CoawaitExprClass:
451 case Expr::CoyieldExprClass:
452 return ClassifyInternal(Ctx, cast<CoroutineSuspendExpr>(E)->getResumeExpr());
453 case Expr::SYCLUniqueStableNameExprClass:
457 case Expr::CXXParenListInitExprClass:
458 if (isa<ArrayType>(E->
getType()))
463 llvm_unreachable(
"unhandled expression kind in classification");
476 if (
const auto *M = dyn_cast<CXXMethodDecl>(D)) {
477 if (M->isImplicitObjectMemberFunction())
485 if (
const auto *NTTParm = dyn_cast<NonTypeTemplateParmDecl>(D))
486 islvalue = NTTParm->getType()->isReferenceType() ||
487 NTTParm->getType()->isRecordType();
493 (isa<FunctionDecl, MSPropertyDecl, FunctionTemplateDecl>(D)));
532 if (isa<ObjCPropertyRefExpr>(
Base))
541 if (
const auto *
Value = dyn_cast<ValueDecl>(
Member))
547 if (isa<VarDecl>(
Member) &&
Member->getDeclContext()->isRecord())
553 if (isa<FieldDecl>(
Member)) {
558 if (isa<ObjCPropertyRefExpr>(
Base))
567 if (
const auto *Method = dyn_cast<CXXMethodDecl>(
Member)) {
568 if (Method->isStatic())
570 if (Method->isImplicitObjectMemberFunction())
582 "This is only relevant for C++.");
618 "This is only relevant for C++.");
629 if (
const Expr *NonThrow = TrueIsThrow ? (FalseIsThrow ?
nullptr : False)
630 : (FalseIsThrow ? True :
nullptr))
654 if (
const auto *CE = dyn_cast<ExplicitCastExpr>(E->
IgnoreParens())) {
655 if (CE->getSubExpr()->IgnoreParenImpCasts()->isLValue()) {
656 Loc = CE->getExprLoc();
671 if (
const auto *
Expr = dyn_cast<ObjCPropertyRefExpr>(E)) {
672 if (
Expr->isImplicitProperty() &&
673 Expr->getImplicitPropertySetter() ==
nullptr)
686 if (CT->isArrayType())
689 if (CT->isIncompleteType())
694 if (R->hasConstFields())
716 llvm_unreachable(
"Unhandled kind");
743 case Cl::CM_RValue: llvm_unreachable(
"CM_RValue and CL_LValue don't match");
746 llvm_unreachable(
"CM_LValueCast and CL_LValue don't match");
754 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.
The JSON file list parser is used to communicate input to InstallAPI.
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.
const FunctionProtoType * T