contrib/llvm/tools/clang/lib/AST/ExprClassification.cpp

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