• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===--- ExprClassification.cpp - Expression AST Node Implementation ------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements Expr::classify.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/AST/Expr.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/DeclCXX.h"
17 #include "clang/AST/DeclObjC.h"
18 #include "clang/AST/DeclTemplate.h"
19 #include "clang/AST/ExprCXX.h"
20 #include "clang/AST/ExprObjC.h"
21 #include "llvm/Support/ErrorHandling.h"
22 using namespace clang;
23 
24 typedef Expr::Classification Cl;
25 
26 static Cl::Kinds ClassifyInternal(ASTContext &Ctx, const Expr *E);
27 static Cl::Kinds ClassifyDecl(ASTContext &Ctx, const Decl *D);
28 static Cl::Kinds ClassifyUnnamed(ASTContext &Ctx, QualType T);
29 static Cl::Kinds ClassifyMemberExpr(ASTContext &Ctx, const MemberExpr *E);
30 static Cl::Kinds ClassifyBinaryOp(ASTContext &Ctx, const BinaryOperator *E);
31 static Cl::Kinds ClassifyConditional(ASTContext &Ctx,
32                                      const Expr *trueExpr,
33                                      const Expr *falseExpr);
34 static Cl::ModifiableType IsModifiable(ASTContext &Ctx, const Expr *E,
35                                        Cl::Kinds Kind, SourceLocation &Loc);
36 
ClassifyImpl(ASTContext & Ctx,SourceLocation * Loc) const37 Cl Expr::ClassifyImpl(ASTContext &Ctx, SourceLocation *Loc) const {
38   assert(!TR->isReferenceType() && "Expressions can't have reference type.");
39 
40   Cl::Kinds kind = ClassifyInternal(Ctx, this);
41   // C99 6.3.2.1: An lvalue is an expression with an object type or an
42   //   incomplete type other than void.
43   if (!Ctx.getLangOpts().CPlusPlus) {
44     // Thus, no functions.
45     if (TR->isFunctionType() || TR == Ctx.OverloadTy)
46       kind = Cl::CL_Function;
47     // No void either, but qualified void is OK because it is "other than void".
48     // Void "lvalues" are classified as addressable void values, which are void
49     // expressions whose address can be taken.
50     else if (TR->isVoidType() && !TR.hasQualifiers())
51       kind = (kind == Cl::CL_LValue ? Cl::CL_AddressableVoid : Cl::CL_Void);
52   }
53 
54   // Enable this assertion for testing.
55   switch (kind) {
56   case Cl::CL_LValue: assert(getValueKind() == VK_LValue); break;
57   case Cl::CL_XValue: assert(getValueKind() == VK_XValue); break;
58   case Cl::CL_Function:
59   case Cl::CL_Void:
60   case Cl::CL_AddressableVoid:
61   case Cl::CL_DuplicateVectorComponents:
62   case Cl::CL_MemberFunction:
63   case Cl::CL_SubObjCPropertySetting:
64   case Cl::CL_ClassTemporary:
65   case Cl::CL_ArrayTemporary:
66   case Cl::CL_ObjCMessageRValue:
67   case Cl::CL_PRValue: assert(getValueKind() == VK_RValue); break;
68   }
69 
70   Cl::ModifiableType modifiable = Cl::CM_Untested;
71   if (Loc)
72     modifiable = IsModifiable(Ctx, this, kind, *Loc);
73   return Classification(kind, modifiable);
74 }
75 
76 /// Classify an expression which creates a temporary, based on its type.
ClassifyTemporary(QualType T)77 static Cl::Kinds ClassifyTemporary(QualType T) {
78   if (T->isRecordType())
79     return Cl::CL_ClassTemporary;
80   if (T->isArrayType())
81     return Cl::CL_ArrayTemporary;
82 
83   // No special classification: these don't behave differently from normal
84   // prvalues.
85   return Cl::CL_PRValue;
86 }
87 
ClassifyExprValueKind(const LangOptions & Lang,const Expr * E,ExprValueKind Kind)88 static Cl::Kinds ClassifyExprValueKind(const LangOptions &Lang,
89                                        const Expr *E,
90                                        ExprValueKind Kind) {
91   switch (Kind) {
92   case VK_RValue:
93     return Lang.CPlusPlus ? ClassifyTemporary(E->getType()) : Cl::CL_PRValue;
94   case VK_LValue:
95     return Cl::CL_LValue;
96   case VK_XValue:
97     return Cl::CL_XValue;
98   }
99   llvm_unreachable("Invalid value category of implicit cast.");
100 }
101 
ClassifyInternal(ASTContext & Ctx,const Expr * E)102 static Cl::Kinds ClassifyInternal(ASTContext &Ctx, const Expr *E) {
103   // This function takes the first stab at classifying expressions.
104   const LangOptions &Lang = Ctx.getLangOpts();
105 
106   switch (E->getStmtClass()) {
107   case Stmt::NoStmtClass:
108 #define ABSTRACT_STMT(Kind)
109 #define STMT(Kind, Base) case Expr::Kind##Class:
110 #define EXPR(Kind, Base)
111 #include "clang/AST/StmtNodes.inc"
112     llvm_unreachable("cannot classify a statement");
113 
114     // First come the expressions that are always lvalues, unconditionally.
115   case Expr::ObjCIsaExprClass:
116     // C++ [expr.prim.general]p1: A string literal is an lvalue.
117   case Expr::StringLiteralClass:
118     // @encode is equivalent to its string
119   case Expr::ObjCEncodeExprClass:
120     // __func__ and friends are too.
121   case Expr::PredefinedExprClass:
122     // Property references are lvalues
123   case Expr::ObjCSubscriptRefExprClass:
124   case Expr::ObjCPropertyRefExprClass:
125     // C++ [expr.typeid]p1: The result of a typeid expression is an lvalue of...
126   case Expr::CXXTypeidExprClass:
127     // Unresolved lookups and uncorrected typos get classified as lvalues.
128     // FIXME: Is this wise? Should they get their own kind?
129   case Expr::UnresolvedLookupExprClass:
130   case Expr::UnresolvedMemberExprClass:
131   case Expr::TypoExprClass:
132   case Expr::CXXDependentScopeMemberExprClass:
133   case Expr::DependentScopeDeclRefExprClass:
134     // ObjC instance variables are lvalues
135     // FIXME: ObjC++0x might have different rules
136   case Expr::ObjCIvarRefExprClass:
137   case Expr::FunctionParmPackExprClass:
138   case Expr::MSPropertyRefExprClass:
139   case Expr::MSPropertySubscriptExprClass:
140   case Expr::OMPArraySectionExprClass:
141     return Cl::CL_LValue;
142 
143     // C99 6.5.2.5p5 says that compound literals are lvalues.
144     // In C++, they're prvalue temporaries.
145   case Expr::CompoundLiteralExprClass:
146     return Ctx.getLangOpts().CPlusPlus ? ClassifyTemporary(E->getType())
147                                        : Cl::CL_LValue;
148 
149     // Expressions that are prvalues.
150   case Expr::CXXBoolLiteralExprClass:
151   case Expr::CXXPseudoDestructorExprClass:
152   case Expr::UnaryExprOrTypeTraitExprClass:
153   case Expr::CXXNewExprClass:
154   case Expr::CXXThisExprClass:
155   case Expr::CXXNullPtrLiteralExprClass:
156   case Expr::ImaginaryLiteralClass:
157   case Expr::GNUNullExprClass:
158   case Expr::OffsetOfExprClass:
159   case Expr::CXXThrowExprClass:
160   case Expr::ShuffleVectorExprClass:
161   case Expr::ConvertVectorExprClass:
162   case Expr::IntegerLiteralClass:
163   case Expr::CharacterLiteralClass:
164   case Expr::AddrLabelExprClass:
165   case Expr::CXXDeleteExprClass:
166   case Expr::ImplicitValueInitExprClass:
167   case Expr::BlockExprClass:
168   case Expr::FloatingLiteralClass:
169   case Expr::CXXNoexceptExprClass:
170   case Expr::CXXScalarValueInitExprClass:
171   case Expr::TypeTraitExprClass:
172   case Expr::ArrayTypeTraitExprClass:
173   case Expr::ExpressionTraitExprClass:
174   case Expr::ObjCSelectorExprClass:
175   case Expr::ObjCProtocolExprClass:
176   case Expr::ObjCStringLiteralClass:
177   case Expr::ObjCBoxedExprClass:
178   case Expr::ObjCArrayLiteralClass:
179   case Expr::ObjCDictionaryLiteralClass:
180   case Expr::ObjCBoolLiteralExprClass:
181   case Expr::ParenListExprClass:
182   case Expr::SizeOfPackExprClass:
183   case Expr::SubstNonTypeTemplateParmPackExprClass:
184   case Expr::AsTypeExprClass:
185   case Expr::ObjCIndirectCopyRestoreExprClass:
186   case Expr::AtomicExprClass:
187   case Expr::CXXFoldExprClass:
188   case Expr::NoInitExprClass:
189   case Expr::DesignatedInitUpdateExprClass:
190   case Expr::CoyieldExprClass:
191     return Cl::CL_PRValue;
192 
193     // Next come the complicated cases.
194   case Expr::SubstNonTypeTemplateParmExprClass:
195     return ClassifyInternal(Ctx,
196                  cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement());
197 
198     // C++ [expr.sub]p1: The result is an lvalue of type "T".
199     // However, subscripting vector types is more like member access.
200   case Expr::ArraySubscriptExprClass:
201     if (cast<ArraySubscriptExpr>(E)->getBase()->getType()->isVectorType())
202       return ClassifyInternal(Ctx, cast<ArraySubscriptExpr>(E)->getBase());
203     return Cl::CL_LValue;
204 
205     // C++ [expr.prim.general]p3: The result is an lvalue if the entity is a
206     //   function or variable and a prvalue otherwise.
207   case Expr::DeclRefExprClass:
208     if (E->getType() == Ctx.UnknownAnyTy)
209       return isa<FunctionDecl>(cast<DeclRefExpr>(E)->getDecl())
210                ? Cl::CL_PRValue : Cl::CL_LValue;
211     return ClassifyDecl(Ctx, cast<DeclRefExpr>(E)->getDecl());
212 
213     // Member access is complex.
214   case Expr::MemberExprClass:
215     return ClassifyMemberExpr(Ctx, cast<MemberExpr>(E));
216 
217   case Expr::UnaryOperatorClass:
218     switch (cast<UnaryOperator>(E)->getOpcode()) {
219       // C++ [expr.unary.op]p1: The unary * operator performs indirection:
220       //   [...] the result is an lvalue referring to the object or function
221       //   to which the expression points.
222     case UO_Deref:
223       return Cl::CL_LValue;
224 
225       // GNU extensions, simply look through them.
226     case UO_Extension:
227       return ClassifyInternal(Ctx, cast<UnaryOperator>(E)->getSubExpr());
228 
229     // Treat _Real and _Imag basically as if they were member
230     // expressions:  l-value only if the operand is a true l-value.
231     case UO_Real:
232     case UO_Imag: {
233       const Expr *Op = cast<UnaryOperator>(E)->getSubExpr()->IgnoreParens();
234       Cl::Kinds K = ClassifyInternal(Ctx, Op);
235       if (K != Cl::CL_LValue) return K;
236 
237       if (isa<ObjCPropertyRefExpr>(Op))
238         return Cl::CL_SubObjCPropertySetting;
239       return Cl::CL_LValue;
240     }
241 
242       // C++ [expr.pre.incr]p1: The result is the updated operand; it is an
243       //   lvalue, [...]
244       // Not so in C.
245     case UO_PreInc:
246     case UO_PreDec:
247       return Lang.CPlusPlus ? Cl::CL_LValue : Cl::CL_PRValue;
248 
249     default:
250       return Cl::CL_PRValue;
251     }
252 
253   case Expr::OpaqueValueExprClass:
254     return ClassifyExprValueKind(Lang, E, E->getValueKind());
255 
256     // Pseudo-object expressions can produce l-values with reference magic.
257   case Expr::PseudoObjectExprClass:
258     return ClassifyExprValueKind(Lang, E,
259                                  cast<PseudoObjectExpr>(E)->getValueKind());
260 
261     // Implicit casts are lvalues if they're lvalue casts. Other than that, we
262     // only specifically record class temporaries.
263   case Expr::ImplicitCastExprClass:
264     return ClassifyExprValueKind(Lang, E, E->getValueKind());
265 
266     // C++ [expr.prim.general]p4: The presence of parentheses does not affect
267     //   whether the expression is an lvalue.
268   case Expr::ParenExprClass:
269     return ClassifyInternal(Ctx, cast<ParenExpr>(E)->getSubExpr());
270 
271     // C11 6.5.1.1p4: [A generic selection] is an lvalue, a function designator,
272     // or a void expression if its result expression is, respectively, an
273     // lvalue, a function designator, or a void expression.
274   case Expr::GenericSelectionExprClass:
275     if (cast<GenericSelectionExpr>(E)->isResultDependent())
276       return Cl::CL_PRValue;
277     return ClassifyInternal(Ctx,cast<GenericSelectionExpr>(E)->getResultExpr());
278 
279   case Expr::BinaryOperatorClass:
280   case Expr::CompoundAssignOperatorClass:
281     // C doesn't have any binary expressions that are lvalues.
282     if (Lang.CPlusPlus)
283       return ClassifyBinaryOp(Ctx, cast<BinaryOperator>(E));
284     return Cl::CL_PRValue;
285 
286   case Expr::CallExprClass:
287   case Expr::CXXOperatorCallExprClass:
288   case Expr::CXXMemberCallExprClass:
289   case Expr::UserDefinedLiteralClass:
290   case Expr::CUDAKernelCallExprClass:
291     return ClassifyUnnamed(Ctx, cast<CallExpr>(E)->getCallReturnType(Ctx));
292 
293     // __builtin_choose_expr is equivalent to the chosen expression.
294   case Expr::ChooseExprClass:
295     return ClassifyInternal(Ctx, cast<ChooseExpr>(E)->getChosenSubExpr());
296 
297     // Extended vector element access is an lvalue unless there are duplicates
298     // in the shuffle expression.
299   case Expr::ExtVectorElementExprClass:
300     if (cast<ExtVectorElementExpr>(E)->containsDuplicateElements())
301       return Cl::CL_DuplicateVectorComponents;
302     if (cast<ExtVectorElementExpr>(E)->isArrow())
303       return Cl::CL_LValue;
304     return ClassifyInternal(Ctx, cast<ExtVectorElementExpr>(E)->getBase());
305 
306     // Simply look at the actual default argument.
307   case Expr::CXXDefaultArgExprClass:
308     return ClassifyInternal(Ctx, cast<CXXDefaultArgExpr>(E)->getExpr());
309 
310     // Same idea for default initializers.
311   case Expr::CXXDefaultInitExprClass:
312     return ClassifyInternal(Ctx, cast<CXXDefaultInitExpr>(E)->getExpr());
313 
314     // Same idea for temporary binding.
315   case Expr::CXXBindTemporaryExprClass:
316     return ClassifyInternal(Ctx, cast<CXXBindTemporaryExpr>(E)->getSubExpr());
317 
318     // And the cleanups guard.
319   case Expr::ExprWithCleanupsClass:
320     return ClassifyInternal(Ctx, cast<ExprWithCleanups>(E)->getSubExpr());
321 
322     // Casts depend completely on the target type. All casts work the same.
323   case Expr::CStyleCastExprClass:
324   case Expr::CXXFunctionalCastExprClass:
325   case Expr::CXXStaticCastExprClass:
326   case Expr::CXXDynamicCastExprClass:
327   case Expr::CXXReinterpretCastExprClass:
328   case Expr::CXXConstCastExprClass:
329   case Expr::ObjCBridgedCastExprClass:
330     // Only in C++ can casts be interesting at all.
331     if (!Lang.CPlusPlus) return Cl::CL_PRValue;
332     return ClassifyUnnamed(Ctx, cast<ExplicitCastExpr>(E)->getTypeAsWritten());
333 
334   case Expr::CXXUnresolvedConstructExprClass:
335     return ClassifyUnnamed(Ctx,
336                       cast<CXXUnresolvedConstructExpr>(E)->getTypeAsWritten());
337 
338   case Expr::BinaryConditionalOperatorClass: {
339     if (!Lang.CPlusPlus) return Cl::CL_PRValue;
340     const BinaryConditionalOperator *co = cast<BinaryConditionalOperator>(E);
341     return ClassifyConditional(Ctx, co->getTrueExpr(), co->getFalseExpr());
342   }
343 
344   case Expr::ConditionalOperatorClass: {
345     // Once again, only C++ is interesting.
346     if (!Lang.CPlusPlus) return Cl::CL_PRValue;
347     const ConditionalOperator *co = cast<ConditionalOperator>(E);
348     return ClassifyConditional(Ctx, co->getTrueExpr(), co->getFalseExpr());
349   }
350 
351     // ObjC message sends are effectively function calls, if the target function
352     // is known.
353   case Expr::ObjCMessageExprClass:
354     if (const ObjCMethodDecl *Method =
355           cast<ObjCMessageExpr>(E)->getMethodDecl()) {
356       Cl::Kinds kind = ClassifyUnnamed(Ctx, Method->getReturnType());
357       return (kind == Cl::CL_PRValue) ? Cl::CL_ObjCMessageRValue : kind;
358     }
359     return Cl::CL_PRValue;
360 
361     // Some C++ expressions are always class temporaries.
362   case Expr::CXXConstructExprClass:
363   case Expr::CXXInheritedCtorInitExprClass:
364   case Expr::CXXTemporaryObjectExprClass:
365   case Expr::LambdaExprClass:
366   case Expr::CXXStdInitializerListExprClass:
367     return Cl::CL_ClassTemporary;
368 
369   case Expr::VAArgExprClass:
370     return ClassifyUnnamed(Ctx, E->getType());
371 
372   case Expr::DesignatedInitExprClass:
373     return ClassifyInternal(Ctx, cast<DesignatedInitExpr>(E)->getInit());
374 
375   case Expr::StmtExprClass: {
376     const CompoundStmt *S = cast<StmtExpr>(E)->getSubStmt();
377     if (const Expr *LastExpr = dyn_cast_or_null<Expr>(S->body_back()))
378       return ClassifyUnnamed(Ctx, LastExpr->getType());
379     return Cl::CL_PRValue;
380   }
381 
382   case Expr::CXXUuidofExprClass:
383     return Cl::CL_LValue;
384 
385   case Expr::PackExpansionExprClass:
386     return ClassifyInternal(Ctx, cast<PackExpansionExpr>(E)->getPattern());
387 
388   case Expr::MaterializeTemporaryExprClass:
389     return cast<MaterializeTemporaryExpr>(E)->isBoundToLvalueReference()
390               ? Cl::CL_LValue
391               : Cl::CL_XValue;
392 
393   case Expr::InitListExprClass:
394     // An init list can be an lvalue if it is bound to a reference and
395     // contains only one element. In that case, we look at that element
396     // for an exact classification. Init list creation takes care of the
397     // value kind for us, so we only need to fine-tune.
398     if (E->isRValue())
399       return ClassifyExprValueKind(Lang, E, E->getValueKind());
400     assert(cast<InitListExpr>(E)->getNumInits() == 1 &&
401            "Only 1-element init lists can be glvalues.");
402     return ClassifyInternal(Ctx, cast<InitListExpr>(E)->getInit(0));
403 
404   case Expr::CoawaitExprClass:
405     return ClassifyInternal(Ctx, cast<CoawaitExpr>(E)->getResumeExpr());
406   }
407 
408   llvm_unreachable("unhandled expression kind in classification");
409 }
410 
411 /// ClassifyDecl - Return the classification of an expression referencing the
412 /// given declaration.
ClassifyDecl(ASTContext & Ctx,const Decl * D)413 static Cl::Kinds ClassifyDecl(ASTContext &Ctx, const Decl *D) {
414   // C++ [expr.prim.general]p6: The result is an lvalue if the entity is a
415   //   function, variable, or data member and a prvalue otherwise.
416   // In C, functions are not lvalues.
417   // In addition, NonTypeTemplateParmDecl derives from VarDecl but isn't an
418   // lvalue unless it's a reference type (C++ [temp.param]p6), so we need to
419   // special-case this.
420 
421   if (isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance())
422     return Cl::CL_MemberFunction;
423 
424   bool islvalue;
425   if (const NonTypeTemplateParmDecl *NTTParm =
426         dyn_cast<NonTypeTemplateParmDecl>(D))
427     islvalue = NTTParm->getType()->isReferenceType();
428   else
429     islvalue = isa<VarDecl>(D) || isa<FieldDecl>(D) ||
430                isa<IndirectFieldDecl>(D) ||
431                (Ctx.getLangOpts().CPlusPlus &&
432                 (isa<FunctionDecl>(D) || isa<MSPropertyDecl>(D) ||
433                  isa<FunctionTemplateDecl>(D)));
434 
435   return islvalue ? Cl::CL_LValue : Cl::CL_PRValue;
436 }
437 
438 /// ClassifyUnnamed - Return the classification of an expression yielding an
439 /// unnamed value of the given type. This applies in particular to function
440 /// calls and casts.
ClassifyUnnamed(ASTContext & Ctx,QualType T)441 static Cl::Kinds ClassifyUnnamed(ASTContext &Ctx, QualType T) {
442   // In C, function calls are always rvalues.
443   if (!Ctx.getLangOpts().CPlusPlus) return Cl::CL_PRValue;
444 
445   // C++ [expr.call]p10: A function call is an lvalue if the result type is an
446   //   lvalue reference type or an rvalue reference to function type, an xvalue
447   //   if the result type is an rvalue reference to object type, and a prvalue
448   //   otherwise.
449   if (T->isLValueReferenceType())
450     return Cl::CL_LValue;
451   const RValueReferenceType *RV = T->getAs<RValueReferenceType>();
452   if (!RV) // Could still be a class temporary, though.
453     return ClassifyTemporary(T);
454 
455   return RV->getPointeeType()->isFunctionType() ? Cl::CL_LValue : Cl::CL_XValue;
456 }
457 
ClassifyMemberExpr(ASTContext & Ctx,const MemberExpr * E)458 static Cl::Kinds ClassifyMemberExpr(ASTContext &Ctx, const MemberExpr *E) {
459   if (E->getType() == Ctx.UnknownAnyTy)
460     return (isa<FunctionDecl>(E->getMemberDecl())
461               ? Cl::CL_PRValue : Cl::CL_LValue);
462 
463   // Handle C first, it's easier.
464   if (!Ctx.getLangOpts().CPlusPlus) {
465     // C99 6.5.2.3p3
466     // For dot access, the expression is an lvalue if the first part is. For
467     // arrow access, it always is an lvalue.
468     if (E->isArrow())
469       return Cl::CL_LValue;
470     // ObjC property accesses are not lvalues, but get special treatment.
471     Expr *Base = E->getBase()->IgnoreParens();
472     if (isa<ObjCPropertyRefExpr>(Base))
473       return Cl::CL_SubObjCPropertySetting;
474     return ClassifyInternal(Ctx, Base);
475   }
476 
477   NamedDecl *Member = E->getMemberDecl();
478   // C++ [expr.ref]p3: E1->E2 is converted to the equivalent form (*(E1)).E2.
479   // C++ [expr.ref]p4: If E2 is declared to have type "reference to T", then
480   //   E1.E2 is an lvalue.
481   if (ValueDecl *Value = dyn_cast<ValueDecl>(Member))
482     if (Value->getType()->isReferenceType())
483       return Cl::CL_LValue;
484 
485   //   Otherwise, one of the following rules applies.
486   //   -- If E2 is a static member [...] then E1.E2 is an lvalue.
487   if (isa<VarDecl>(Member) && Member->getDeclContext()->isRecord())
488     return Cl::CL_LValue;
489 
490   //   -- If E2 is a non-static data member [...]. If E1 is an lvalue, then
491   //      E1.E2 is an lvalue; if E1 is an xvalue, then E1.E2 is an xvalue;
492   //      otherwise, it is a prvalue.
493   if (isa<FieldDecl>(Member)) {
494     // *E1 is an lvalue
495     if (E->isArrow())
496       return Cl::CL_LValue;
497     Expr *Base = E->getBase()->IgnoreParenImpCasts();
498     if (isa<ObjCPropertyRefExpr>(Base))
499       return Cl::CL_SubObjCPropertySetting;
500     return ClassifyInternal(Ctx, E->getBase());
501   }
502 
503   //   -- If E2 is a [...] member function, [...]
504   //      -- If it refers to a static member function [...], then E1.E2 is an
505   //         lvalue; [...]
506   //      -- Otherwise [...] E1.E2 is a prvalue.
507   if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member))
508     return Method->isStatic() ? Cl::CL_LValue : Cl::CL_MemberFunction;
509 
510   //   -- If E2 is a member enumerator [...], the expression E1.E2 is a prvalue.
511   // So is everything else we haven't handled yet.
512   return Cl::CL_PRValue;
513 }
514 
ClassifyBinaryOp(ASTContext & Ctx,const BinaryOperator * E)515 static Cl::Kinds ClassifyBinaryOp(ASTContext &Ctx, const BinaryOperator *E) {
516   assert(Ctx.getLangOpts().CPlusPlus &&
517          "This is only relevant for C++.");
518   // C++ [expr.ass]p1: All [...] return an lvalue referring to the left operand.
519   // Except we override this for writes to ObjC properties.
520   if (E->isAssignmentOp())
521     return (E->getLHS()->getObjectKind() == OK_ObjCProperty
522               ? Cl::CL_PRValue : Cl::CL_LValue);
523 
524   // C++ [expr.comma]p1: the result is of the same value category as its right
525   //   operand, [...].
526   if (E->getOpcode() == BO_Comma)
527     return ClassifyInternal(Ctx, E->getRHS());
528 
529   // C++ [expr.mptr.oper]p6: The result of a .* expression whose second operand
530   //   is a pointer to a data member is of the same value category as its first
531   //   operand.
532   if (E->getOpcode() == BO_PtrMemD)
533     return (E->getType()->isFunctionType() ||
534             E->hasPlaceholderType(BuiltinType::BoundMember))
535              ? Cl::CL_MemberFunction
536              : ClassifyInternal(Ctx, E->getLHS());
537 
538   // C++ [expr.mptr.oper]p6: The result of an ->* expression is an lvalue if its
539   //   second operand is a pointer to data member and a prvalue otherwise.
540   if (E->getOpcode() == BO_PtrMemI)
541     return (E->getType()->isFunctionType() ||
542             E->hasPlaceholderType(BuiltinType::BoundMember))
543              ? Cl::CL_MemberFunction
544              : Cl::CL_LValue;
545 
546   // All other binary operations are prvalues.
547   return Cl::CL_PRValue;
548 }
549 
ClassifyConditional(ASTContext & Ctx,const Expr * True,const Expr * False)550 static Cl::Kinds ClassifyConditional(ASTContext &Ctx, const Expr *True,
551                                      const Expr *False) {
552   assert(Ctx.getLangOpts().CPlusPlus &&
553          "This is only relevant for C++.");
554 
555   // C++ [expr.cond]p2
556   //   If either the second or the third operand has type (cv) void,
557   //   one of the following shall hold:
558   if (True->getType()->isVoidType() || False->getType()->isVoidType()) {
559     // The second or the third operand (but not both) is a (possibly
560     // parenthesized) throw-expression; the result is of the [...] value
561     // category of the other.
562     bool TrueIsThrow = isa<CXXThrowExpr>(True->IgnoreParenImpCasts());
563     bool FalseIsThrow = isa<CXXThrowExpr>(False->IgnoreParenImpCasts());
564     if (const Expr *NonThrow = TrueIsThrow ? (FalseIsThrow ? nullptr : False)
565                                            : (FalseIsThrow ? True : nullptr))
566       return ClassifyInternal(Ctx, NonThrow);
567 
568     //   [Otherwise] the result [...] is a prvalue.
569     return Cl::CL_PRValue;
570   }
571 
572   // Note that at this point, we have already performed all conversions
573   // according to [expr.cond]p3.
574   // C++ [expr.cond]p4: If the second and third operands are glvalues of the
575   //   same value category [...], the result is of that [...] value category.
576   // C++ [expr.cond]p5: Otherwise, the result is a prvalue.
577   Cl::Kinds LCl = ClassifyInternal(Ctx, True),
578             RCl = ClassifyInternal(Ctx, False);
579   return LCl == RCl ? LCl : Cl::CL_PRValue;
580 }
581 
IsModifiable(ASTContext & Ctx,const Expr * E,Cl::Kinds Kind,SourceLocation & Loc)582 static Cl::ModifiableType IsModifiable(ASTContext &Ctx, const Expr *E,
583                                        Cl::Kinds Kind, SourceLocation &Loc) {
584   // As a general rule, we only care about lvalues. But there are some rvalues
585   // for which we want to generate special results.
586   if (Kind == Cl::CL_PRValue) {
587     // For the sake of better diagnostics, we want to specifically recognize
588     // use of the GCC cast-as-lvalue extension.
589     if (const ExplicitCastExpr *CE =
590           dyn_cast<ExplicitCastExpr>(E->IgnoreParens())) {
591       if (CE->getSubExpr()->IgnoreParenImpCasts()->isLValue()) {
592         Loc = CE->getExprLoc();
593         return Cl::CM_LValueCast;
594       }
595     }
596   }
597   if (Kind != Cl::CL_LValue)
598     return Cl::CM_RValue;
599 
600   // This is the lvalue case.
601   // Functions are lvalues in C++, but not modifiable. (C++ [basic.lval]p6)
602   if (Ctx.getLangOpts().CPlusPlus && E->getType()->isFunctionType())
603     return Cl::CM_Function;
604 
605   // Assignment to a property in ObjC is an implicit setter access. But a
606   // setter might not exist.
607   if (const ObjCPropertyRefExpr *Expr = dyn_cast<ObjCPropertyRefExpr>(E)) {
608     if (Expr->isImplicitProperty() &&
609         Expr->getImplicitPropertySetter() == nullptr)
610       return Cl::CM_NoSetterProperty;
611   }
612 
613   CanQualType CT = Ctx.getCanonicalType(E->getType());
614   // Const stuff is obviously not modifiable.
615   if (CT.isConstQualified())
616     return Cl::CM_ConstQualified;
617   if (CT.getQualifiers().getAddressSpace() == LangAS::opencl_constant)
618     return Cl::CM_ConstAddrSpace;
619 
620   // Arrays are not modifiable, only their elements are.
621   if (CT->isArrayType())
622     return Cl::CM_ArrayType;
623   // Incomplete types are not modifiable.
624   if (CT->isIncompleteType())
625     return Cl::CM_IncompleteType;
626 
627   // Records with any const fields (recursively) are not modifiable.
628   if (const RecordType *R = CT->getAs<RecordType>())
629     if (R->hasConstFields())
630       return Cl::CM_ConstQualified;
631 
632   return Cl::CM_Modifiable;
633 }
634 
ClassifyLValue(ASTContext & Ctx) const635 Expr::LValueClassification Expr::ClassifyLValue(ASTContext &Ctx) const {
636   Classification VC = Classify(Ctx);
637   switch (VC.getKind()) {
638   case Cl::CL_LValue: return LV_Valid;
639   case Cl::CL_XValue: return LV_InvalidExpression;
640   case Cl::CL_Function: return LV_NotObjectType;
641   case Cl::CL_Void: return LV_InvalidExpression;
642   case Cl::CL_AddressableVoid: return LV_IncompleteVoidType;
643   case Cl::CL_DuplicateVectorComponents: return LV_DuplicateVectorComponents;
644   case Cl::CL_MemberFunction: return LV_MemberFunction;
645   case Cl::CL_SubObjCPropertySetting: return LV_SubObjCPropertySetting;
646   case Cl::CL_ClassTemporary: return LV_ClassTemporary;
647   case Cl::CL_ArrayTemporary: return LV_ArrayTemporary;
648   case Cl::CL_ObjCMessageRValue: return LV_InvalidMessageExpression;
649   case Cl::CL_PRValue: return LV_InvalidExpression;
650   }
651   llvm_unreachable("Unhandled kind");
652 }
653 
654 Expr::isModifiableLvalueResult
isModifiableLvalue(ASTContext & Ctx,SourceLocation * Loc) const655 Expr::isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc) const {
656   SourceLocation dummy;
657   Classification VC = ClassifyModifiable(Ctx, Loc ? *Loc : dummy);
658   switch (VC.getKind()) {
659   case Cl::CL_LValue: break;
660   case Cl::CL_XValue: return MLV_InvalidExpression;
661   case Cl::CL_Function: return MLV_NotObjectType;
662   case Cl::CL_Void: return MLV_InvalidExpression;
663   case Cl::CL_AddressableVoid: return MLV_IncompleteVoidType;
664   case Cl::CL_DuplicateVectorComponents: return MLV_DuplicateVectorComponents;
665   case Cl::CL_MemberFunction: return MLV_MemberFunction;
666   case Cl::CL_SubObjCPropertySetting: return MLV_SubObjCPropertySetting;
667   case Cl::CL_ClassTemporary: return MLV_ClassTemporary;
668   case Cl::CL_ArrayTemporary: return MLV_ArrayTemporary;
669   case Cl::CL_ObjCMessageRValue: return MLV_InvalidMessageExpression;
670   case Cl::CL_PRValue:
671     return VC.getModifiable() == Cl::CM_LValueCast ?
672       MLV_LValueCast : MLV_InvalidExpression;
673   }
674   assert(VC.getKind() == Cl::CL_LValue && "Unhandled kind");
675   switch (VC.getModifiable()) {
676   case Cl::CM_Untested: llvm_unreachable("Did not test modifiability");
677   case Cl::CM_Modifiable: return MLV_Valid;
678   case Cl::CM_RValue: llvm_unreachable("CM_RValue and CL_LValue don't match");
679   case Cl::CM_Function: return MLV_NotObjectType;
680   case Cl::CM_LValueCast:
681     llvm_unreachable("CM_LValueCast and CL_LValue don't match");
682   case Cl::CM_NoSetterProperty: return MLV_NoSetterProperty;
683   case Cl::CM_ConstQualified: return MLV_ConstQualified;
684   case Cl::CM_ConstAddrSpace: return MLV_ConstAddrSpace;
685   case Cl::CM_ArrayType: return MLV_ArrayType;
686   case Cl::CM_IncompleteType: return MLV_IncompleteType;
687   }
688   llvm_unreachable("Unhandled modifiable type");
689 }
690