20 #include "llvm/Support/ErrorHandling.h"
22 using namespace clang;
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:
205 case Expr::SYCLBuiltinNumFieldsExprClass:
206 case Expr::SYCLBuiltinFieldTypeExprClass:
207 case Expr::SYCLBuiltinNumBasesExprClass:
208 case Expr::SYCLBuiltinBaseTypeExprClass:
212 case Expr::CXXThisExprClass:
215 case Expr::ConstantExprClass:
219 case Expr::SubstNonTypeTemplateParmExprClass:
221 cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement());
223 case Expr::PackIndexingExprClass: {
226 if (cast<PackIndexingExpr>(E)->isInstantiationDependent())
235 case Expr::ArraySubscriptExprClass:
236 if (cast<ArraySubscriptExpr>(E)->
getBase()->getType()->isVectorType())
238 if (
Lang.CPlusPlus11) {
241 auto *
Base = cast<ArraySubscriptExpr>(E)->getBase()->IgnoreImpCasts();
242 if (
Base->getType()->isArrayType())
248 case Expr::MatrixSubscriptExprClass:
253 case Expr::DeclRefExprClass:
255 return isa<FunctionDecl>(cast<DeclRefExpr>(E)->getDecl())
257 return ClassifyDecl(Ctx, cast<DeclRefExpr>(E)->getDecl());
260 case Expr::MemberExprClass:
263 case Expr::UnaryOperatorClass:
264 switch (cast<UnaryOperator>(E)->getOpcode()) {
283 if (isa<ObjCPropertyRefExpr>(Op))
299 case Expr::RecoveryExprClass:
300 case Expr::OpaqueValueExprClass:
304 case Expr::PseudoObjectExprClass:
306 cast<PseudoObjectExpr>(E)->getValueKind());
310 case Expr::ImplicitCastExprClass:
315 case Expr::ParenExprClass:
321 case Expr::GenericSelectionExprClass:
322 if (cast<GenericSelectionExpr>(E)->isResultDependent())
324 return ClassifyInternal(Ctx,cast<GenericSelectionExpr>(E)->getResultExpr());
326 case Expr::BinaryOperatorClass:
327 case Expr::CompoundAssignOperatorClass:
333 case Expr::CallExprClass:
334 case Expr::CXXOperatorCallExprClass:
335 case Expr::CXXMemberCallExprClass:
336 case Expr::UserDefinedLiteralClass:
337 case Expr::CUDAKernelCallExprClass:
338 return ClassifyUnnamed(Ctx, cast<CallExpr>(E)->getCallReturnType(Ctx));
340 case Expr::CXXRewrittenBinaryOperatorClass:
342 Ctx, cast<CXXRewrittenBinaryOperator>(E)->getSemanticForm());
345 case Expr::ChooseExprClass:
350 case Expr::ExtVectorElementExprClass:
351 if (cast<ExtVectorElementExpr>(E)->containsDuplicateElements())
353 if (cast<ExtVectorElementExpr>(E)->isArrow())
358 case Expr::CXXDefaultArgExprClass:
362 case Expr::CXXDefaultInitExprClass:
366 case Expr::CXXBindTemporaryExprClass:
370 case Expr::ExprWithCleanupsClass:
374 case Expr::CStyleCastExprClass:
375 case Expr::CXXFunctionalCastExprClass:
376 case Expr::CXXStaticCastExprClass:
377 case Expr::CXXDynamicCastExprClass:
378 case Expr::CXXReinterpretCastExprClass:
379 case Expr::CXXConstCastExprClass:
380 case Expr::CXXAddrspaceCastExprClass:
381 case Expr::ObjCBridgedCastExprClass:
382 case Expr::BuiltinBitCastExprClass:
385 return ClassifyUnnamed(Ctx, cast<ExplicitCastExpr>(E)->getTypeAsWritten());
387 case Expr::CXXUnresolvedConstructExprClass:
389 cast<CXXUnresolvedConstructExpr>(E)->getTypeAsWritten());
391 case Expr::BinaryConditionalOperatorClass: {
393 const auto *co = cast<BinaryConditionalOperator>(E);
397 case Expr::ConditionalOperatorClass: {
400 const auto *co = cast<ConditionalOperator>(E);
406 case Expr::ObjCMessageExprClass:
408 cast<ObjCMessageExpr>(E)->getMethodDecl()) {
415 case Expr::CXXConstructExprClass:
416 case Expr::CXXInheritedCtorInitExprClass:
417 case Expr::CXXTemporaryObjectExprClass:
418 case Expr::LambdaExprClass:
419 case Expr::CXXStdInitializerListExprClass:
422 case Expr::VAArgExprClass:
425 case Expr::DesignatedInitExprClass:
428 case Expr::StmtExprClass: {
429 const CompoundStmt *S = cast<StmtExpr>(E)->getSubStmt();
430 if (
const auto *LastExpr = dyn_cast_or_null<Expr>(S->body_back()))
435 case Expr::PackExpansionExprClass:
438 case Expr::MaterializeTemporaryExprClass:
439 return cast<MaterializeTemporaryExpr>(E)->isBoundToLvalueReference()
443 case Expr::InitListExprClass:
450 assert(cast<InitListExpr>(E)->getNumInits() == 1 &&
451 "Only 1-element init lists can be glvalues.");
454 case Expr::CoawaitExprClass:
455 case Expr::CoyieldExprClass:
456 return ClassifyInternal(Ctx, cast<CoroutineSuspendExpr>(E)->getResumeExpr());
457 case Expr::SYCLUniqueStableNameExprClass:
458 case Expr::SYCLUniqueStableIdExprClass:
462 case Expr::CXXParenListInitExprClass:
463 if (isa<ArrayType>(E->
getType()))
468 llvm_unreachable(
"unhandled expression kind in classification");
481 if (
const auto *M = dyn_cast<CXXMethodDecl>(D)) {
482 if (M->isImplicitObjectMemberFunction())
490 if (
const auto *NTTParm = dyn_cast<NonTypeTemplateParmDecl>(D))
491 islvalue = NTTParm->getType()->isReferenceType() ||
492 NTTParm->getType()->isRecordType();
498 (isa<FunctionDecl, MSPropertyDecl, FunctionTemplateDecl>(D)));
537 if (isa<ObjCPropertyRefExpr>(
Base))
546 if (
const auto *
Value = dyn_cast<ValueDecl>(
Member))
552 if (isa<VarDecl>(
Member) &&
Member->getDeclContext()->isRecord())
558 if (isa<FieldDecl>(
Member)) {
563 if (isa<ObjCPropertyRefExpr>(
Base))
572 if (
const auto *Method = dyn_cast<CXXMethodDecl>(
Member)) {
573 if (Method->isStatic())
575 if (Method->isImplicitObjectMemberFunction())
587 "This is only relevant for C++.");
623 "This is only relevant for C++.");
634 if (
const Expr *NonThrow = TrueIsThrow ? (FalseIsThrow ?
nullptr : False)
635 : (FalseIsThrow ? True :
nullptr))
659 if (
const auto *CE = dyn_cast<ExplicitCastExpr>(E->
IgnoreParens())) {
660 if (CE->getSubExpr()->IgnoreParenImpCasts()->isLValue()) {
661 Loc = CE->getExprLoc();
676 if (
const auto *
Expr = dyn_cast<ObjCPropertyRefExpr>(E)) {
677 if (
Expr->isImplicitProperty() &&
678 Expr->getImplicitPropertySetter() ==
nullptr)
691 if (CT->isArrayType())
694 if (CT->isIncompleteType())
699 if (R->hasConstFields())
721 llvm_unreachable(
"Unhandled kind");
748 case Cl::CM_RValue: llvm_unreachable(
"CM_RValue and CL_LValue don't match");
751 llvm_unreachable(
"CM_LValueCast and CL_LValue don't match");
759 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.
unsigned kind
All of the diagnostics that can be emitted by the frontend.
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