contrib/llvm/tools/clang/lib/Sema/SemaPseudoObject.cpp

   1 //===--- SemaPseudoObject.cpp - Semantic Analysis for Pseudo-Objects ------===//
   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 semantic analysis for expressions involving
  11 //  pseudo-object references.  Pseudo-objects are conceptual objects
  12 //  whose storage is entirely abstract and all accesses to which are
  13 //  translated through some sort of abstraction barrier.
  14 //
  15 //  For example, Objective-C objects can have "properties", either
  16 //  declared or undeclared.  A property may be accessed by writing
  17 //    expr.prop
  18 //  where 'expr' is an r-value of Objective-C pointer type and 'prop'
  19 //  is the name of the property.  If this expression is used in a context
  20 //  needing an r-value, it is treated as if it were a message-send
  21 //  of the associated 'getter' selector, typically:
  22 //    [expr prop]
  23 //  If it is used as the LHS of a simple assignment, it is treated
  24 //  as a message-send of the associated 'setter' selector, typically:
  25 //    [expr setProp: RHS]
  26 //  If it is used as the LHS of a compound assignment, or the operand
  27 //  of a unary increment or decrement, both are required;  for example,
  28 //  'expr.prop *= 100' would be translated to:
  29 //    [expr setProp: [expr prop] * 100]
  30 //
  31 //===----------------------------------------------------------------------===//
  32
  33 #include "clang/Sema/SemaInternal.h"
  34 #include "clang/Sema/Initialization.h"
  35 #include "clang/AST/ExprObjC.h"
  36 #include "clang/Lex/Preprocessor.h"
  37
  38 using namespace clang;
  39 using namespace sema;
  40
  41 namespace {
  42   // Basically just a very focused copy of TreeTransform.
  43   template <class T> struct Rebuilder {
  44     Sema &S;
  45     Rebuilder(Sema &S) : S(S) {}
  46
  47     T &getDerived() { return static_cast<T&>(*this); }
  48
  49     Expr *rebuild(Expr *e) {
  50       // Fast path: nothing to look through.
  51       if (typename T::specific_type *specific
  52             = dyn_cast<typename T::specific_type>(e))
  53         return getDerived().rebuildSpecific(specific);
  54
  55       // Otherwise, we should look through and rebuild anything that
  56       // IgnoreParens would.
  57
  58       if (ParenExpr *parens = dyn_cast<ParenExpr>(e)) {
  59         e = rebuild(parens->getSubExpr());
  60         return new (S.Context) ParenExpr(parens->getLParen(),
  61                                          parens->getRParen(),
  62                                          e);
  63       }
  64
  65       if (UnaryOperator *uop = dyn_cast<UnaryOperator>(e)) {
  66         assert(uop->getOpcode() == UO_Extension);
  67         e = rebuild(uop->getSubExpr());
  68         return new (S.Context) UnaryOperator(e, uop->getOpcode(),
  69                                              uop->getType(),
  70                                              uop->getValueKind(),
  71                                              uop->getObjectKind(),
  72                                              uop->getOperatorLoc());
  73       }
  74
  75       if (GenericSelectionExpr *gse = dyn_cast<GenericSelectionExpr>(e)) {
  76         assert(!gse->isResultDependent());
  77         unsigned resultIndex = gse->getResultIndex();
  78         unsigned numAssocs = gse->getNumAssocs();
  79
  80         SmallVector<Expr*, 8> assocs(numAssocs);
  81         SmallVector<TypeSourceInfo*, 8> assocTypes(numAssocs);
  82
  83         for (unsigned i = 0; i != numAssocs; ++i) {
  84           Expr *assoc = gse->getAssocExpr(i);
  85           if (i == resultIndex) assoc = rebuild(assoc);
  86           assocs[i] = assoc;
  87           assocTypes[i] = gse->getAssocTypeSourceInfo(i);
  88         }
  89
  90         return new (S.Context) GenericSelectionExpr(S.Context,
  91                                                     gse->getGenericLoc(),
  92                                                     gse->getControllingExpr(),
  93                                                     assocTypes.data(),
  94                                                     assocs.data(),
  95                                                     numAssocs,
  96                                                     gse->getDefaultLoc(),
  97                                                     gse->getRParenLoc(),
  98                                       gse->containsUnexpandedParameterPack(),
  99                                                     resultIndex);
 100       }
 101
 102       llvm_unreachable("bad expression to rebuild!");
 103     }
 104   };
 105
 106   struct ObjCPropertyRefRebuilder : Rebuilder<ObjCPropertyRefRebuilder> {
 107     Expr *NewBase;
 108     ObjCPropertyRefRebuilder(Sema &S, Expr *newBase)
 109       : Rebuilder<ObjCPropertyRefRebuilder>(S), NewBase(newBase) {}
 110
 111     typedef ObjCPropertyRefExpr specific_type;
 112     Expr *rebuildSpecific(ObjCPropertyRefExpr *refExpr) {
 113       // Fortunately, the constraint that we're rebuilding something
 114       // with a base limits the number of cases here.
 115       assert(refExpr->getBase());
 116
 117       if (refExpr->isExplicitProperty()) {
 118         return new (S.Context)
 119           ObjCPropertyRefExpr(refExpr->getExplicitProperty(),
 120                               refExpr->getType(), refExpr->getValueKind(),
 121                               refExpr->getObjectKind(), refExpr->getLocation(),
 122                               NewBase);
 123       }
 124       return new (S.Context)
 125         ObjCPropertyRefExpr(refExpr->getImplicitPropertyGetter(),
 126                             refExpr->getImplicitPropertySetter(),
 127                             refExpr->getType(), refExpr->getValueKind(),
 128                             refExpr->getObjectKind(),refExpr->getLocation(),
 129                             NewBase);
 130     }
 131   };
 132
 133   struct ObjCSubscriptRefRebuilder : Rebuilder<ObjCSubscriptRefRebuilder> {
 134     Expr *NewBase;
 135     Expr *NewKeyExpr;
 136     ObjCSubscriptRefRebuilder(Sema &S, Expr *newBase, Expr *newKeyExpr)
 137     : Rebuilder<ObjCSubscriptRefRebuilder>(S),
 138       NewBase(newBase), NewKeyExpr(newKeyExpr) {}
 139
 140     typedef ObjCSubscriptRefExpr specific_type;
 141     Expr *rebuildSpecific(ObjCSubscriptRefExpr *refExpr) {
 142       assert(refExpr->getBaseExpr());
 143       assert(refExpr->getKeyExpr());
 144
 145       return new (S.Context)
 146         ObjCSubscriptRefExpr(NewBase,
 147                              NewKeyExpr,
 148                              refExpr->getType(), refExpr->getValueKind(),
 149                              refExpr->getObjectKind(),refExpr->getAtIndexMethodDecl(),
 150                              refExpr->setAtIndexMethodDecl(),
 151                              refExpr->getRBracket());
 152     }
 153   };
 154
 155   class PseudoOpBuilder {
 156   public:
 157     Sema &S;
 158     unsigned ResultIndex;
 159     SourceLocation GenericLoc;
 160     SmallVector<Expr *, 4> Semantics;
 161
 162     PseudoOpBuilder(Sema &S, SourceLocation genericLoc)
 163       : S(S), ResultIndex(PseudoObjectExpr::NoResult),
 164         GenericLoc(genericLoc) {}
 165
 166     virtual ~PseudoOpBuilder() {}
 167
 168     /// Add a normal semantic expression.
 169     void addSemanticExpr(Expr *semantic) {
 170       Semantics.push_back(semantic);
 171     }
 172
 173     /// Add the 'result' semantic expression.
 174     void addResultSemanticExpr(Expr *resultExpr) {
 175       assert(ResultIndex == PseudoObjectExpr::NoResult);
 176       ResultIndex = Semantics.size();
 177       Semantics.push_back(resultExpr);
 178     }
 179
 180     ExprResult buildRValueOperation(Expr *op);
 181     ExprResult buildAssignmentOperation(Scope *Sc,
 182                                         SourceLocation opLoc,
 183                                         BinaryOperatorKind opcode,
 184                                         Expr *LHS, Expr *RHS);
 185     ExprResult buildIncDecOperation(Scope *Sc, SourceLocation opLoc,
 186                                     UnaryOperatorKind opcode,
 187                                     Expr *op);
 188
 189     ExprResult complete(Expr *syntacticForm);
 190
 191     OpaqueValueExpr *capture(Expr *op);
 192     OpaqueValueExpr *captureValueAsResult(Expr *op);
 193
 194     void setResultToLastSemantic() {
 195       assert(ResultIndex == PseudoObjectExpr::NoResult);
 196       ResultIndex = Semantics.size() - 1;
 197     }
 198
 199     /// Return true if assignments have a non-void result.
 200     virtual bool assignmentsHaveResult() { return true; }
 201
 202     virtual Expr *rebuildAndCaptureObject(Expr *) = 0;
 203     virtual ExprResult buildGet() = 0;
 204     virtual ExprResult buildSet(Expr *, SourceLocation,
 205                                 bool captureSetValueAsResult) = 0;
 206   };
 207
 208   /// A PseudoOpBuilder for Objective-C @properties.
 209   class ObjCPropertyOpBuilder : public PseudoOpBuilder {
 210     ObjCPropertyRefExpr *RefExpr;
 211     ObjCPropertyRefExpr *SyntacticRefExpr;
 212     OpaqueValueExpr *InstanceReceiver;
 213     ObjCMethodDecl *Getter;
 214
 215     ObjCMethodDecl *Setter;
 216     Selector SetterSelector;
 217     Selector GetterSelector;
 218
 219   public:
 220     ObjCPropertyOpBuilder(Sema &S, ObjCPropertyRefExpr *refExpr) :
 221       PseudoOpBuilder(S, refExpr->getLocation()), RefExpr(refExpr),
 222       SyntacticRefExpr(0), InstanceReceiver(0), Getter(0), Setter(0) {
 223     }
 224
 225     ExprResult buildRValueOperation(Expr *op);
 226     ExprResult buildAssignmentOperation(Scope *Sc,
 227                                         SourceLocation opLoc,
 228                                         BinaryOperatorKind opcode,
 229                                         Expr *LHS, Expr *RHS);
 230     ExprResult buildIncDecOperation(Scope *Sc, SourceLocation opLoc,
 231                                     UnaryOperatorKind opcode,
 232                                     Expr *op);
 233
 234     bool tryBuildGetOfReference(Expr *op, ExprResult &result);
 235     bool findSetter();
 236     bool findGetter();
 237
 238     Expr *rebuildAndCaptureObject(Expr *syntacticBase);
 239     ExprResult buildGet();
 240     ExprResult buildSet(Expr *op, SourceLocation, bool);
 241   };
 242
 243  /// A PseudoOpBuilder for Objective-C array/dictionary indexing.
 244  class ObjCSubscriptOpBuilder : public PseudoOpBuilder {
 245    ObjCSubscriptRefExpr *RefExpr;
 246    OpaqueValueExpr *InstanceBase;
 247    OpaqueValueExpr *InstanceKey;
 248    ObjCMethodDecl *AtIndexGetter;
 249    Selector AtIndexGetterSelector;
 250
 251    ObjCMethodDecl *AtIndexSetter;
 252    Selector AtIndexSetterSelector;
 253
 254  public:
 255     ObjCSubscriptOpBuilder(Sema &S, ObjCSubscriptRefExpr *refExpr) :
 256       PseudoOpBuilder(S, refExpr->getSourceRange().getBegin()),
 257       RefExpr(refExpr),
 258     InstanceBase(0), InstanceKey(0),
 259     AtIndexGetter(0), AtIndexSetter(0) { }
 260
 261    ExprResult buildRValueOperation(Expr *op);
 262    ExprResult buildAssignmentOperation(Scope *Sc,
 263                                        SourceLocation opLoc,
 264                                        BinaryOperatorKind opcode,
 265                                        Expr *LHS, Expr *RHS);
 266    Expr *rebuildAndCaptureObject(Expr *syntacticBase);
 267
 268    bool findAtIndexGetter();
 269    bool findAtIndexSetter();
 270
 271    ExprResult buildGet();
 272    ExprResult buildSet(Expr *op, SourceLocation, bool);
 273  };
 274
 275 }
 276
 277 /// Capture the given expression in an OpaqueValueExpr.
 278 OpaqueValueExpr *PseudoOpBuilder::capture(Expr *e) {
 279   // Make a new OVE whose source is the given expression.
 280   OpaqueValueExpr *captured =
 281     new (S.Context) OpaqueValueExpr(GenericLoc, e->getType(),
 282                                     e->getValueKind(), e->getObjectKind(),
 283                                     e);
 284
 285   // Make sure we bind that in the semantics.
 286   addSemanticExpr(captured);
 287   return captured;
 288 }
 289
 290 /// Capture the given expression as the result of this pseudo-object
 291 /// operation.  This routine is safe against expressions which may
 292 /// already be captured.
 293 ///
 294 /// \param Returns the captured expression, which will be the
 295 ///   same as the input if the input was already captured
 296 OpaqueValueExpr *PseudoOpBuilder::captureValueAsResult(Expr *e) {
 297   assert(ResultIndex == PseudoObjectExpr::NoResult);
 298
 299   // If the expression hasn't already been captured, just capture it
 300   // and set the new semantic
 301   if (!isa<OpaqueValueExpr>(e)) {
 302     OpaqueValueExpr *cap = capture(e);
 303     setResultToLastSemantic();
 304     return cap;
 305   }
 306
 307   // Otherwise, it must already be one of our semantic expressions;
 308   // set ResultIndex to its index.
 309   unsigned index = 0;
 310   for (;; ++index) {
 311     assert(index < Semantics.size() &&
 312            "captured expression not found in semantics!");
 313     if (e == Semantics[index]) break;
 314   }
 315   ResultIndex = index;
 316   return cast<OpaqueValueExpr>(e);
 317 }
 318
 319 /// The routine which creates the final PseudoObjectExpr.
 320 ExprResult PseudoOpBuilder::complete(Expr *syntactic) {
 321   return PseudoObjectExpr::Create(S.Context, syntactic,
 322                                   Semantics, ResultIndex);
 323 }
 324
 325 /// The main skeleton for building an r-value operation.
 326 ExprResult PseudoOpBuilder::buildRValueOperation(Expr *op) {
 327   Expr *syntacticBase = rebuildAndCaptureObject(op);
 328
 329   ExprResult getExpr = buildGet();
 330   if (getExpr.isInvalid()) return ExprError();
 331   addResultSemanticExpr(getExpr.take());
 332
 333   return complete(syntacticBase);
 334 }
 335
 336 /// The basic skeleton for building a simple or compound
 337 /// assignment operation.
 338 ExprResult
 339 PseudoOpBuilder::buildAssignmentOperation(Scope *Sc, SourceLocation opcLoc,
 340                                           BinaryOperatorKind opcode,
 341                                           Expr *LHS, Expr *RHS) {
 342   assert(BinaryOperator::isAssignmentOp(opcode));
 343
 344   Expr *syntacticLHS = rebuildAndCaptureObject(LHS);
 345   OpaqueValueExpr *capturedRHS = capture(RHS);
 346
 347   Expr *syntactic;
 348
 349   ExprResult result;
 350   if (opcode == BO_Assign) {
 351     result = capturedRHS;
 352     syntactic = new (S.Context) BinaryOperator(syntacticLHS, capturedRHS,
 353                                                opcode, capturedRHS->getType(),
 354                                                capturedRHS->getValueKind(),
 355                                                OK_Ordinary, opcLoc);
 356   } else {
 357     ExprResult opLHS = buildGet();
 358     if (opLHS.isInvalid()) return ExprError();
 359
 360     // Build an ordinary, non-compound operation.
 361     BinaryOperatorKind nonCompound =
 362       BinaryOperator::getOpForCompoundAssignment(opcode);
 363     result = S.BuildBinOp(Sc, opcLoc, nonCompound,
 364                           opLHS.take(), capturedRHS);
 365     if (result.isInvalid()) return ExprError();
 366
 367     syntactic =
 368       new (S.Context) CompoundAssignOperator(syntacticLHS, capturedRHS, opcode,
 369                                              result.get()->getType(),
 370                                              result.get()->getValueKind(),
 371                                              OK_Ordinary,
 372                                              opLHS.get()->getType(),
 373                                              result.get()->getType(),
 374                                              opcLoc);
 375   }
 376
 377   // The result of the assignment, if not void, is the value set into
 378   // the l-value.
 379   result = buildSet(result.take(), opcLoc, assignmentsHaveResult());
 380   if (result.isInvalid()) return ExprError();
 381   addSemanticExpr(result.take());
 382
 383   return complete(syntactic);
 384 }
 385
 386 /// The basic skeleton for building an increment or decrement
 387 /// operation.
 388 ExprResult
 389 PseudoOpBuilder::buildIncDecOperation(Scope *Sc, SourceLocation opcLoc,
 390                                       UnaryOperatorKind opcode,
 391                                       Expr *op) {
 392   assert(UnaryOperator::isIncrementDecrementOp(opcode));
 393
 394   Expr *syntacticOp = rebuildAndCaptureObject(op);
 395
 396   // Load the value.
 397   ExprResult result = buildGet();
 398   if (result.isInvalid()) return ExprError();
 399
 400   QualType resultType = result.get()->getType();
 401
 402   // That's the postfix result.
 403   if (UnaryOperator::isPostfix(opcode) && assignmentsHaveResult()) {
 404     result = capture(result.take());
 405     setResultToLastSemantic();
 406   }
 407
 408   // Add or subtract a literal 1.
 409   llvm::APInt oneV(S.Context.getTypeSize(S.Context.IntTy), 1);
 410   Expr *one = IntegerLiteral::Create(S.Context, oneV, S.Context.IntTy,
 411                                      GenericLoc);
 412
 413   if (UnaryOperator::isIncrementOp(opcode)) {
 414     result = S.BuildBinOp(Sc, opcLoc, BO_Add, result.take(), one);
 415   } else {
 416     result = S.BuildBinOp(Sc, opcLoc, BO_Sub, result.take(), one);
 417   }
 418   if (result.isInvalid()) return ExprError();
 419
 420   // Store that back into the result.  The value stored is the result
 421   // of a prefix operation.
 422   result = buildSet(result.take(), opcLoc,
 423              UnaryOperator::isPrefix(opcode) && assignmentsHaveResult());
 424   if (result.isInvalid()) return ExprError();
 425   addSemanticExpr(result.take());
 426
 427   UnaryOperator *syntactic =
 428     new (S.Context) UnaryOperator(syntacticOp, opcode, resultType,
 429                                   VK_LValue, OK_Ordinary, opcLoc);
 430   return complete(syntactic);
 431 }
 432
 433
 434 //===----------------------------------------------------------------------===//
 435 //  Objective-C @property and implicit property references
 436 //===----------------------------------------------------------------------===//
 437
 438 /// Look up a method in the receiver type of an Objective-C property
 439 /// reference.
 440 static ObjCMethodDecl *LookupMethodInReceiverType(Sema &S, Selector sel,
 441                                             const ObjCPropertyRefExpr *PRE) {
 442   if (PRE->isObjectReceiver()) {
 443     const ObjCObjectPointerType *PT =
 444       PRE->getBase()->getType()->castAs<ObjCObjectPointerType>();
 445
 446     // Special case for 'self' in class method implementations.
 447     if (PT->isObjCClassType() &&
 448         S.isSelfExpr(const_cast<Expr*>(PRE->getBase()))) {
 449       // This cast is safe because isSelfExpr is only true within
 450       // methods.
 451       ObjCMethodDecl *method =
 452         cast<ObjCMethodDecl>(S.CurContext->getNonClosureAncestor());
 453       return S.LookupMethodInObjectType(sel,
 454                  S.Context.getObjCInterfaceType(method->getClassInterface()),
 455                                         /*instance*/ false);
 456     }
 457
 458     return S.LookupMethodInObjectType(sel, PT->getPointeeType(), true);
 459   }
 460
 461   if (PRE->isSuperReceiver()) {
 462     if (const ObjCObjectPointerType *PT =
 463         PRE->getSuperReceiverType()->getAs<ObjCObjectPointerType>())
 464       return S.LookupMethodInObjectType(sel, PT->getPointeeType(), true);
 465
 466     return S.LookupMethodInObjectType(sel, PRE->getSuperReceiverType(), false);
 467   }
 468
 469   assert(PRE->isClassReceiver() && "Invalid expression");
 470   QualType IT = S.Context.getObjCInterfaceType(PRE->getClassReceiver());
 471   return S.LookupMethodInObjectType(sel, IT, false);
 472 }
 473
 474 bool ObjCPropertyOpBuilder::findGetter() {
 475   if (Getter) return true;
 476
 477   // For implicit properties, just trust the lookup we already did.
 478   if (RefExpr->isImplicitProperty()) {
 479     if ((Getter = RefExpr->getImplicitPropertyGetter())) {
 480       GetterSelector = Getter->getSelector();
 481       return true;
 482     }
 483     else {
 484       // Must build the getter selector the hard way.
 485       ObjCMethodDecl *setter = RefExpr->getImplicitPropertySetter();
 486       assert(setter && "both setter and getter are null - cannot happen");
 487       IdentifierInfo *setterName =
 488         setter->getSelector().getIdentifierInfoForSlot(0);
 489       const char *compStr = setterName->getNameStart();
 490       compStr += 3;
 491       IdentifierInfo *getterName = &S.Context.Idents.get(compStr);
 492       GetterSelector =
 493         S.PP.getSelectorTable().getNullarySelector(getterName);
 494       return false;
 495
 496     }
 497   }
 498
 499   ObjCPropertyDecl *prop = RefExpr->getExplicitProperty();
 500   Getter = LookupMethodInReceiverType(S, prop->getGetterName(), RefExpr);
 501   return (Getter != 0);
 502 }
 503
 504 /// Try to find the most accurate setter declaration for the property
 505 /// reference.
 506 ///
 507 /// \return true if a setter was found, in which case Setter
 508 bool ObjCPropertyOpBuilder::findSetter() {
 509   // For implicit properties, just trust the lookup we already did.
 510   if (RefExpr->isImplicitProperty()) {
 511     if (ObjCMethodDecl *setter = RefExpr->getImplicitPropertySetter()) {
 512       Setter = setter;
 513       SetterSelector = setter->getSelector();
 514       return true;
 515     } else {
 516       IdentifierInfo *getterName =
 517         RefExpr->getImplicitPropertyGetter()->getSelector()
 518           .getIdentifierInfoForSlot(0);
 519       SetterSelector =
 520         SelectorTable::constructSetterName(S.PP.getIdentifierTable(),
 521                                            S.PP.getSelectorTable(),
 522                                            getterName);
 523       return false;
 524     }
 525   }
 526
 527   // For explicit properties, this is more involved.
 528   ObjCPropertyDecl *prop = RefExpr->getExplicitProperty();
 529   SetterSelector = prop->getSetterName();
 530
 531   // Do a normal method lookup first.
 532   if (ObjCMethodDecl *setter =
 533         LookupMethodInReceiverType(S, SetterSelector, RefExpr)) {
 534     Setter = setter;
 535     return true;
 536   }
 537
 538   // That can fail in the somewhat crazy situation that we're
 539   // type-checking a message send within the @interface declaration
 540   // that declared the @property.  But it's not clear that that's
 541   // valuable to support.
 542
 543   return false;
 544 }
 545
 546 /// Capture the base object of an Objective-C property expression.
 547 Expr *ObjCPropertyOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
 548   assert(InstanceReceiver == 0);
 549
 550   // If we have a base, capture it in an OVE and rebuild the syntactic
 551   // form to use the OVE as its base.
 552   if (RefExpr->isObjectReceiver()) {
 553     InstanceReceiver = capture(RefExpr->getBase());
 554
 555     syntacticBase =
 556       ObjCPropertyRefRebuilder(S, InstanceReceiver).rebuild(syntacticBase);
 557   }
 558
 559   if (ObjCPropertyRefExpr *
 560         refE = dyn_cast<ObjCPropertyRefExpr>(syntacticBase->IgnoreParens()))
 561     SyntacticRefExpr = refE;
 562
 563   return syntacticBase;
 564 }
 565
 566 /// Load from an Objective-C property reference.
 567 ExprResult ObjCPropertyOpBuilder::buildGet() {
 568   findGetter();
 569   assert(Getter);
 570
 571   if (SyntacticRefExpr)
 572     SyntacticRefExpr->setIsMessagingGetter();
 573
 574   QualType receiverType;
 575   if (RefExpr->isClassReceiver()) {
 576     receiverType = S.Context.getObjCInterfaceType(RefExpr->getClassReceiver());
 577   } else if (RefExpr->isSuperReceiver()) {
 578     receiverType = RefExpr->getSuperReceiverType();
 579   } else {
 580     assert(InstanceReceiver);
 581     receiverType = InstanceReceiver->getType();
 582   }
 583
 584   // Build a message-send.
 585   ExprResult msg;
 586   if (Getter->isInstanceMethod() || RefExpr->isObjectReceiver()) {
 587     assert(InstanceReceiver || RefExpr->isSuperReceiver());
 588     msg = S.BuildInstanceMessageImplicit(InstanceReceiver, receiverType,
 589                                          GenericLoc, Getter->getSelector(),
 590                                          Getter, MultiExprArg());
 591   } else {
 592     msg = S.BuildClassMessageImplicit(receiverType, RefExpr->isSuperReceiver(),
 593                                       GenericLoc,
 594                                       Getter->getSelector(), Getter,
 595                                       MultiExprArg());
 596   }
 597   return msg;
 598 }
 599
 600 /// Store to an Objective-C property reference.
 601 ///
 602 /// \param bindSetValueAsResult - If true, capture the actual
 603 ///   value being set as the value of the property operation.
 604 ExprResult ObjCPropertyOpBuilder::buildSet(Expr *op, SourceLocation opcLoc,
 605                                            bool captureSetValueAsResult) {
 606   bool hasSetter = findSetter();
 607   assert(hasSetter); (void) hasSetter;
 608
 609   if (SyntacticRefExpr)
 610     SyntacticRefExpr->setIsMessagingSetter();
 611
 612   QualType receiverType;
 613   if (RefExpr->isClassReceiver()) {
 614     receiverType = S.Context.getObjCInterfaceType(RefExpr->getClassReceiver());
 615   } else if (RefExpr->isSuperReceiver()) {
 616     receiverType = RefExpr->getSuperReceiverType();
 617   } else {
 618     assert(InstanceReceiver);
 619     receiverType = InstanceReceiver->getType();
 620   }
 621
 622   // Use assignment constraints when possible; they give us better
 623   // diagnostics.  "When possible" basically means anything except a
 624   // C++ class type.
 625   if (!S.getLangOpts().CPlusPlus || !op->getType()->isRecordType()) {
 626     QualType paramType = (*Setter->param_begin())->getType();
 627     if (!S.getLangOpts().CPlusPlus || !paramType->isRecordType()) {
 628       ExprResult opResult = op;
 629       Sema::AssignConvertType assignResult
 630         = S.CheckSingleAssignmentConstraints(paramType, opResult);
 631       if (S.DiagnoseAssignmentResult(assignResult, opcLoc, paramType,
 632                                      op->getType(), opResult.get(),
 633                                      Sema::AA_Assigning))
 634         return ExprError();
 635
 636       op = opResult.take();
 637       assert(op && "successful assignment left argument invalid?");
 638     }
 639   }
 640
 641   // Arguments.
 642   Expr *args[] = { op };
 643
 644   // Build a message-send.
 645   ExprResult msg;
 646   if (Setter->isInstanceMethod() || RefExpr->isObjectReceiver()) {
 647     msg = S.BuildInstanceMessageImplicit(InstanceReceiver, receiverType,
 648                                          GenericLoc, SetterSelector, Setter,
 649                                          MultiExprArg(args, 1));
 650   } else {
 651     msg = S.BuildClassMessageImplicit(receiverType, RefExpr->isSuperReceiver(),
 652                                       GenericLoc,
 653                                       SetterSelector, Setter,
 654                                       MultiExprArg(args, 1));
 655   }
 656
 657   if (!msg.isInvalid() && captureSetValueAsResult) {
 658     ObjCMessageExpr *msgExpr =
 659       cast<ObjCMessageExpr>(msg.get()->IgnoreImplicit());
 660     Expr *arg = msgExpr->getArg(0);
 661     msgExpr->setArg(0, captureValueAsResult(arg));
 662   }
 663
 664   return msg;
 665 }
 666
 667 /// @property-specific behavior for doing lvalue-to-rvalue conversion.
 668 ExprResult ObjCPropertyOpBuilder::buildRValueOperation(Expr *op) {
 669   // Explicit properties always have getters, but implicit ones don't.
 670   // Check that before proceeding.
 671   if (RefExpr->isImplicitProperty() &&
 672       !RefExpr->getImplicitPropertyGetter()) {
 673     S.Diag(RefExpr->getLocation(), diag::err_getter_not_found)
 674       << RefExpr->getBase()->getType();
 675     return ExprError();
 676   }
 677
 678   ExprResult result = PseudoOpBuilder::buildRValueOperation(op);
 679   if (result.isInvalid()) return ExprError();
 680
 681   if (RefExpr->isExplicitProperty() && !Getter->hasRelatedResultType())
 682     S.DiagnosePropertyAccessorMismatch(RefExpr->getExplicitProperty(),
 683                                        Getter, RefExpr->getLocation());
 684
 685   // As a special case, if the method returns 'id', try to get
 686   // a better type from the property.
 687   if (RefExpr->isExplicitProperty() && result.get()->isRValue() &&
 688       result.get()->getType()->isObjCIdType()) {
 689     QualType propType = RefExpr->getExplicitProperty()->getType();
 690     if (const ObjCObjectPointerType *ptr
 691           = propType->getAs<ObjCObjectPointerType>()) {
 692       if (!ptr->isObjCIdType())
 693         result = S.ImpCastExprToType(result.get(), propType, CK_BitCast);
 694     }
 695   }
 696
 697   return result;
 698 }
 699
 700 /// Try to build this as a call to a getter that returns a reference.
 701 ///
 702 /// \return true if it was possible, whether or not it actually
 703 ///   succeeded
 704 bool ObjCPropertyOpBuilder::tryBuildGetOfReference(Expr *op,
 705                                                    ExprResult &result) {
 706   if (!S.getLangOpts().CPlusPlus) return false;
 707
 708   findGetter();
 709   assert(Getter && "property has no setter and no getter!");
 710
 711   // Only do this if the getter returns an l-value reference type.
 712   QualType resultType = Getter->getResultType();
 713   if (!resultType->isLValueReferenceType()) return false;
 714
 715   result = buildRValueOperation(op);
 716   return true;
 717 }
 718
 719 /// @property-specific behavior for doing assignments.
 720 ExprResult
 721 ObjCPropertyOpBuilder::buildAssignmentOperation(Scope *Sc,
 722                                                 SourceLocation opcLoc,
 723                                                 BinaryOperatorKind opcode,
 724                                                 Expr *LHS, Expr *RHS) {
 725   assert(BinaryOperator::isAssignmentOp(opcode));
 726
 727   // If there's no setter, we have no choice but to try to assign to
 728   // the result of the getter.
 729   if (!findSetter()) {
 730     ExprResult result;
 731     if (tryBuildGetOfReference(LHS, result)) {
 732       if (result.isInvalid()) return ExprError();
 733       return S.BuildBinOp(Sc, opcLoc, opcode, result.take(), RHS);
 734     }
 735
 736     // Otherwise, it's an error.
 737     S.Diag(opcLoc, diag::err_nosetter_property_assignment)
 738       << unsigned(RefExpr->isImplicitProperty())
 739       << SetterSelector
 740       << LHS->getSourceRange() << RHS->getSourceRange();
 741     return ExprError();
 742   }
 743
 744   // If there is a setter, we definitely want to use it.
 745
 746   // Verify that we can do a compound assignment.
 747   if (opcode != BO_Assign && !findGetter()) {
 748     S.Diag(opcLoc, diag::err_nogetter_property_compound_assignment)
 749       << LHS->getSourceRange() << RHS->getSourceRange();
 750     return ExprError();
 751   }
 752
 753   ExprResult result =
 754     PseudoOpBuilder::buildAssignmentOperation(Sc, opcLoc, opcode, LHS, RHS);
 755   if (result.isInvalid()) return ExprError();
 756
 757   // Various warnings about property assignments in ARC.
 758   if (S.getLangOpts().ObjCAutoRefCount && InstanceReceiver) {
 759     S.checkRetainCycles(InstanceReceiver->getSourceExpr(), RHS);
 760     S.checkUnsafeExprAssigns(opcLoc, LHS, RHS);
 761   }
 762
 763   return result;
 764 }
 765
 766 /// @property-specific behavior for doing increments and decrements.
 767 ExprResult
 768 ObjCPropertyOpBuilder::buildIncDecOperation(Scope *Sc, SourceLocation opcLoc,
 769                                             UnaryOperatorKind opcode,
 770                                             Expr *op) {
 771   // If there's no setter, we have no choice but to try to assign to
 772   // the result of the getter.
 773   if (!findSetter()) {
 774     ExprResult result;
 775     if (tryBuildGetOfReference(op, result)) {
 776       if (result.isInvalid()) return ExprError();
 777       return S.BuildUnaryOp(Sc, opcLoc, opcode, result.take());
 778     }
 779
 780     // Otherwise, it's an error.
 781     S.Diag(opcLoc, diag::err_nosetter_property_incdec)
 782       << unsigned(RefExpr->isImplicitProperty())
 783       << unsigned(UnaryOperator::isDecrementOp(opcode))
 784       << SetterSelector
 785       << op->getSourceRange();
 786     return ExprError();
 787   }
 788
 789   // If there is a setter, we definitely want to use it.
 790
 791   // We also need a getter.
 792   if (!findGetter()) {
 793     assert(RefExpr->isImplicitProperty());
 794     S.Diag(opcLoc, diag::err_nogetter_property_incdec)
 795       << unsigned(UnaryOperator::isDecrementOp(opcode))
 796       << GetterSelector
 797       << op->getSourceRange();
 798     return ExprError();
 799   }
 800
 801   return PseudoOpBuilder::buildIncDecOperation(Sc, opcLoc, opcode, op);
 802 }
 803
 804 // ObjCSubscript build stuff.
 805 //
 806
 807 /// objective-c subscripting-specific behavior for doing lvalue-to-rvalue
 808 /// conversion.
 809 /// FIXME. Remove this routine if it is proven that no additional
 810 /// specifity is needed.
 811 ExprResult ObjCSubscriptOpBuilder::buildRValueOperation(Expr *op) {
 812   ExprResult result = PseudoOpBuilder::buildRValueOperation(op);
 813   if (result.isInvalid()) return ExprError();
 814   return result;
 815 }
 816
 817 /// objective-c subscripting-specific  behavior for doing assignments.
 818 ExprResult
 819 ObjCSubscriptOpBuilder::buildAssignmentOperation(Scope *Sc,
 820                                                 SourceLocation opcLoc,
 821                                                 BinaryOperatorKind opcode,
 822                                                 Expr *LHS, Expr *RHS) {
 823   assert(BinaryOperator::isAssignmentOp(opcode));
 824   // There must be a method to do the Index'ed assignment.
 825   if (!findAtIndexSetter())
 826     return ExprError();
 827
 828   // Verify that we can do a compound assignment.
 829   if (opcode != BO_Assign && !findAtIndexGetter())
 830     return ExprError();
 831
 832   ExprResult result =
 833   PseudoOpBuilder::buildAssignmentOperation(Sc, opcLoc, opcode, LHS, RHS);
 834   if (result.isInvalid()) return ExprError();
 835
 836   // Various warnings about objc Index'ed assignments in ARC.
 837   if (S.getLangOpts().ObjCAutoRefCount && InstanceBase) {
 838     S.checkRetainCycles(InstanceBase->getSourceExpr(), RHS);
 839     S.checkUnsafeExprAssigns(opcLoc, LHS, RHS);
 840   }
 841
 842   return result;
 843 }
 844
 845 /// Capture the base object of an Objective-C Index'ed expression.
 846 Expr *ObjCSubscriptOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
 847   assert(InstanceBase == 0);
 848
 849   // Capture base expression in an OVE and rebuild the syntactic
 850   // form to use the OVE as its base expression.
 851   InstanceBase = capture(RefExpr->getBaseExpr());
 852   InstanceKey = capture(RefExpr->getKeyExpr());
 853
 854   syntacticBase =
 855     ObjCSubscriptRefRebuilder(S, InstanceBase,
 856                               InstanceKey).rebuild(syntacticBase);
 857
 858   return syntacticBase;
 859 }
 860
 861 /// CheckSubscriptingKind - This routine decide what type
 862 /// of indexing represented by "FromE" is being done.
 863 Sema::ObjCSubscriptKind
 864   Sema::CheckSubscriptingKind(Expr *FromE) {
 865   // If the expression already has integral or enumeration type, we're golden.
 866   QualType T = FromE->getType();
 867   if (T->isIntegralOrEnumerationType())
 868     return OS_Array;
 869
 870   // If we don't have a class type in C++, there's no way we can get an
 871   // expression of integral or enumeration type.
 872   const RecordType *RecordTy = T->getAs<RecordType>();
 873   if (!RecordTy && T->isObjCObjectPointerType())
 874     // All other scalar cases are assumed to be dictionary indexing which
 875     // caller handles, with diagnostics if needed.
 876     return OS_Dictionary;
 877   if (!getLangOpts().CPlusPlus ||
 878       !RecordTy || RecordTy->isIncompleteType()) {
 879     // No indexing can be done. Issue diagnostics and quit.
 880     const Expr *IndexExpr = FromE->IgnoreParenImpCasts();
 881     if (isa<StringLiteral>(IndexExpr))
 882       Diag(FromE->getExprLoc(), diag::err_objc_subscript_pointer)
 883         << T << FixItHint::CreateInsertion(FromE->getExprLoc(), "@");
 884     else
 885       Diag(FromE->getExprLoc(), diag::err_objc_subscript_type_conversion)
 886         << T;
 887     return OS_Error;
 888   }
 889
 890   // We must have a complete class type.
 891   if (RequireCompleteType(FromE->getExprLoc(), T,
 892                           PDiag(diag::err_objc_index_incomplete_class_type)
 893                           << FromE->getSourceRange()))
 894     return OS_Error;
 895
 896   // Look for a conversion to an integral, enumeration type, or
 897   // objective-C pointer type.
 898   UnresolvedSet<4> ViableConversions;
 899   UnresolvedSet<4> ExplicitConversions;
 900   const UnresolvedSetImpl *Conversions
 901     = cast<CXXRecordDecl>(RecordTy->getDecl())->getVisibleConversionFunctions();
 902
 903   int NoIntegrals=0, NoObjCIdPointers=0;
 904   SmallVector<CXXConversionDecl *, 4> ConversionDecls;
 905
 906   for (UnresolvedSetImpl::iterator I = Conversions->begin(),
 907        E = Conversions->end();
 908        I != E;
 909        ++I) {
 910     if (CXXConversionDecl *Conversion
 911         = dyn_cast<CXXConversionDecl>((*I)->getUnderlyingDecl())) {
 912       QualType CT = Conversion->getConversionType().getNonReferenceType();
 913       if (CT->isIntegralOrEnumerationType()) {
 914         ++NoIntegrals;
 915         ConversionDecls.push_back(Conversion);
 916       }
 917       else if (CT->isObjCIdType() ||CT->isBlockPointerType()) {
 918         ++NoObjCIdPointers;
 919         ConversionDecls.push_back(Conversion);
 920       }
 921     }
 922   }
 923   if (NoIntegrals ==1 && NoObjCIdPointers == 0)
 924     return OS_Array;
 925   if (NoIntegrals == 0 && NoObjCIdPointers == 1)
 926     return OS_Dictionary;
 927   if (NoIntegrals == 0 && NoObjCIdPointers == 0) {
 928     // No conversion function was found. Issue diagnostic and return.
 929     Diag(FromE->getExprLoc(), diag::err_objc_subscript_type_conversion)
 930       << FromE->getType();
 931     return OS_Error;
 932   }
 933   Diag(FromE->getExprLoc(), diag::err_objc_multiple_subscript_type_conversion)
 934       << FromE->getType();
 935   for (unsigned int i = 0; i < ConversionDecls.size(); i++)
 936     Diag(ConversionDecls[i]->getLocation(), diag::not_conv_function_declared_at);
 937
 938   return OS_Error;
 939 }
 940
 941 bool ObjCSubscriptOpBuilder::findAtIndexGetter() {
 942   if (AtIndexGetter)
 943     return true;
 944
 945   Expr *BaseExpr = RefExpr->getBaseExpr();
 946   QualType BaseT = BaseExpr->getType();
 947
 948   QualType ResultType;
 949   if (const ObjCObjectPointerType *PTy =
 950       BaseT->getAs<ObjCObjectPointerType>()) {
 951     ResultType = PTy->getPointeeType();
 952     if (const ObjCObjectType *iQFaceTy =
 953         ResultType->getAsObjCQualifiedInterfaceType())
 954       ResultType = iQFaceTy->getBaseType();
 955   }
 956   Sema::ObjCSubscriptKind Res =
 957     S.CheckSubscriptingKind(RefExpr->getKeyExpr());
 958   if (Res == Sema::OS_Error)
 959     return false;
 960   bool arrayRef = (Res == Sema::OS_Array);
 961
 962   if (ResultType.isNull()) {
 963     S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_base_type)
 964       << BaseExpr->getType() << arrayRef;
 965     return false;
 966   }
 967   if (!arrayRef) {
 968     // dictionary subscripting.
 969     // - (id)objectForKeyedSubscript:(id)key;
 970     IdentifierInfo *KeyIdents[] = {
 971       &S.Context.Idents.get("objectForKeyedSubscript")
 972     };
 973     AtIndexGetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
 974   }
 975   else {
 976     // - (id)objectAtIndexedSubscript:(size_t)index;
 977     IdentifierInfo *KeyIdents[] = {
 978       &S.Context.Idents.get("objectAtIndexedSubscript")
 979     };
 980
 981     AtIndexGetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
 982   }
 983
 984   AtIndexGetter = S.LookupMethodInObjectType(AtIndexGetterSelector, ResultType,
 985                                              true /*instance*/);
 986   bool receiverIdType = (BaseT->isObjCIdType() ||
 987                          BaseT->isObjCQualifiedIdType());
 988
 989   if (!AtIndexGetter && S.getLangOpts().DebuggerObjCLiteral) {
 990     AtIndexGetter = ObjCMethodDecl::Create(S.Context, SourceLocation(),
 991                            SourceLocation(), AtIndexGetterSelector,
 992                            S.Context.getObjCIdType() /*ReturnType*/,
 993                            0 /*TypeSourceInfo */,
 994                            S.Context.getTranslationUnitDecl(),
 995                            true /*Instance*/, false/*isVariadic*/,
 996                            /*isSynthesized=*/false,
 997                            /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
 998                            ObjCMethodDecl::Required,
 999                            false);
1000     ParmVarDecl *Argument = ParmVarDecl::Create(S.Context, AtIndexGetter,
1001                                                 SourceLocation(), SourceLocation(),
1002                                                 arrayRef ? &S.Context.Idents.get("index")
1003                                                          : &S.Context.Idents.get("key"),
1004                                                 arrayRef ? S.Context.UnsignedLongTy
1005                                                          : S.Context.getObjCIdType(),
1006                                                 /*TInfo=*/0,
1007                                                 SC_None,
1008                                                 SC_None,
1009                                                 0);
1010     AtIndexGetter->setMethodParams(S.Context, Argument,
1011                                    ArrayRef<SourceLocation>());
1012   }
1013
1014   if (!AtIndexGetter) {
1015     if (!receiverIdType) {
1016       S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_method_not_found)
1017       << BaseExpr->getType() << 0 << arrayRef;
1018       return false;
1019     }
1020     AtIndexGetter =
1021       S.LookupInstanceMethodInGlobalPool(AtIndexGetterSelector,
1022                                          RefExpr->getSourceRange(),
1023                                          true, false);
1024   }
1025
1026   if (AtIndexGetter) {
1027     QualType T = AtIndexGetter->param_begin()[0]->getType();
1028     if ((arrayRef && !T->isIntegralOrEnumerationType()) ||
1029         (!arrayRef && !T->isObjCObjectPointerType())) {
1030       S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1031              arrayRef ? diag::err_objc_subscript_index_type
1032                       : diag::err_objc_subscript_key_type) << T;
1033       S.Diag(AtIndexGetter->param_begin()[0]->getLocation(),
1034              diag::note_parameter_type) << T;
1035       return false;
1036     }
1037     QualType R = AtIndexGetter->getResultType();
1038     if (!R->isObjCObjectPointerType()) {
1039       S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1040              diag::err_objc_indexing_method_result_type) << R << arrayRef;
1041       S.Diag(AtIndexGetter->getLocation(), diag::note_method_declared_at) <<
1042         AtIndexGetter->getDeclName();
1043     }
1044   }
1045   return true;
1046 }
1047
1048 bool ObjCSubscriptOpBuilder::findAtIndexSetter() {
1049   if (AtIndexSetter)
1050     return true;
1051
1052   Expr *BaseExpr = RefExpr->getBaseExpr();
1053   QualType BaseT = BaseExpr->getType();
1054
1055   QualType ResultType;
1056   if (const ObjCObjectPointerType *PTy =
1057       BaseT->getAs<ObjCObjectPointerType>()) {
1058     ResultType = PTy->getPointeeType();
1059     if (const ObjCObjectType *iQFaceTy =
1060         ResultType->getAsObjCQualifiedInterfaceType())
1061       ResultType = iQFaceTy->getBaseType();
1062   }
1063
1064   Sema::ObjCSubscriptKind Res =
1065     S.CheckSubscriptingKind(RefExpr->getKeyExpr());
1066   if (Res == Sema::OS_Error)
1067     return false;
1068   bool arrayRef = (Res == Sema::OS_Array);
1069
1070   if (ResultType.isNull()) {
1071     S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_base_type)
1072       << BaseExpr->getType() << arrayRef;
1073     return false;
1074   }
1075
1076   if (!arrayRef) {
1077     // dictionary subscripting.
1078     // - (void)setObject:(id)object forKeyedSubscript:(id)key;
1079     IdentifierInfo *KeyIdents[] = {
1080       &S.Context.Idents.get("setObject"),
1081       &S.Context.Idents.get("forKeyedSubscript")
1082     };
1083     AtIndexSetterSelector = S.Context.Selectors.getSelector(2, KeyIdents);
1084   }
1085   else {
1086     // - (void)setObject:(id)object atIndexedSubscript:(NSInteger)index;
1087     IdentifierInfo *KeyIdents[] = {
1088       &S.Context.Idents.get("setObject"),
1089       &S.Context.Idents.get("atIndexedSubscript")
1090     };
1091     AtIndexSetterSelector = S.Context.Selectors.getSelector(2, KeyIdents);
1092   }
1093   AtIndexSetter = S.LookupMethodInObjectType(AtIndexSetterSelector, ResultType,
1094                                              true /*instance*/);
1095
1096   bool receiverIdType = (BaseT->isObjCIdType() ||
1097                          BaseT->isObjCQualifiedIdType());
1098
1099   if (!AtIndexSetter && S.getLangOpts().DebuggerObjCLiteral) {
1100     TypeSourceInfo *ResultTInfo = 0;
1101     QualType ReturnType = S.Context.VoidTy;
1102     AtIndexSetter = ObjCMethodDecl::Create(S.Context, SourceLocation(),
1103                            SourceLocation(), AtIndexSetterSelector,
1104                            ReturnType,
1105                            ResultTInfo,
1106                            S.Context.getTranslationUnitDecl(),
1107                            true /*Instance*/, false/*isVariadic*/,
1108                            /*isSynthesized=*/false,
1109                            /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
1110                            ObjCMethodDecl::Required,
1111                            false);
1112     SmallVector<ParmVarDecl *, 2> Params;
1113     ParmVarDecl *object = ParmVarDecl::Create(S.Context, AtIndexSetter,
1114                                                 SourceLocation(), SourceLocation(),
1115                                                 &S.Context.Idents.get("object"),
1116                                                 S.Context.getObjCIdType(),
1117                                                 /*TInfo=*/0,
1118                                                 SC_None,
1119                                                 SC_None,
1120                                                 0);
1121     Params.push_back(object);
1122     ParmVarDecl *key = ParmVarDecl::Create(S.Context, AtIndexSetter,
1123                                                 SourceLocation(), SourceLocation(),
1124                                                 arrayRef ?  &S.Context.Idents.get("index")
1125                                                          :  &S.Context.Idents.get("key"),
1126                                                 arrayRef ? S.Context.UnsignedLongTy
1127                                                          : S.Context.getObjCIdType(),
1128                                                 /*TInfo=*/0,
1129                                                 SC_None,
1130                                                 SC_None,
1131                                                 0);
1132     Params.push_back(key);
1133     AtIndexSetter->setMethodParams(S.Context, Params, ArrayRef<SourceLocation>());
1134   }
1135
1136   if (!AtIndexSetter) {
1137     if (!receiverIdType) {
1138       S.Diag(BaseExpr->getExprLoc(),
1139              diag::err_objc_subscript_method_not_found)
1140       << BaseExpr->getType() << 1 << arrayRef;
1141       return false;
1142     }
1143     AtIndexSetter =
1144       S.LookupInstanceMethodInGlobalPool(AtIndexSetterSelector,
1145                                          RefExpr->getSourceRange(),
1146                                          true, false);
1147   }
1148
1149   bool err = false;
1150   if (AtIndexSetter && arrayRef) {
1151     QualType T = AtIndexSetter->param_begin()[1]->getType();
1152     if (!T->isIntegralOrEnumerationType()) {
1153       S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1154              diag::err_objc_subscript_index_type) << T;
1155       S.Diag(AtIndexSetter->param_begin()[1]->getLocation(),
1156              diag::note_parameter_type) << T;
1157       err = true;
1158     }
1159     T = AtIndexSetter->param_begin()[0]->getType();
1160     if (!T->isObjCObjectPointerType()) {
1161       S.Diag(RefExpr->getBaseExpr()->getExprLoc(),
1162              diag::err_objc_subscript_object_type) << T << arrayRef;
1163       S.Diag(AtIndexSetter->param_begin()[0]->getLocation(),
1164              diag::note_parameter_type) << T;
1165       err = true;
1166     }
1167   }
1168   else if (AtIndexSetter && !arrayRef)
1169     for (unsigned i=0; i <2; i++) {
1170       QualType T = AtIndexSetter->param_begin()[i]->getType();
1171       if (!T->isObjCObjectPointerType()) {
1172         if (i == 1)
1173           S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1174                  diag::err_objc_subscript_key_type) << T;
1175         else
1176           S.Diag(RefExpr->getBaseExpr()->getExprLoc(),
1177                  diag::err_objc_subscript_dic_object_type) << T;
1178         S.Diag(AtIndexSetter->param_begin()[i]->getLocation(),
1179                diag::note_parameter_type) << T;
1180         err = true;
1181       }
1182     }
1183
1184   return !err;
1185 }
1186
1187 // Get the object at "Index" position in the container.
1188 // [BaseExpr objectAtIndexedSubscript : IndexExpr];
1189 ExprResult ObjCSubscriptOpBuilder::buildGet() {
1190   if (!findAtIndexGetter())
1191     return ExprError();
1192
1193   QualType receiverType = InstanceBase->getType();
1194
1195   // Build a message-send.
1196   ExprResult msg;
1197   Expr *Index = InstanceKey;
1198
1199   // Arguments.
1200   Expr *args[] = { Index };
1201   assert(InstanceBase);
1202   msg = S.BuildInstanceMessageImplicit(InstanceBase, receiverType,
1203                                        GenericLoc,
1204                                        AtIndexGetterSelector, AtIndexGetter,
1205                                        MultiExprArg(args, 1));
1206   return msg;
1207 }
1208
1209 /// Store into the container the "op" object at "Index"'ed location
1210 /// by building this messaging expression:
1211 /// - (void)setObject:(id)object atIndexedSubscript:(NSInteger)index;
1212 /// \param bindSetValueAsResult - If true, capture the actual
1213 ///   value being set as the value of the property operation.
1214 ExprResult ObjCSubscriptOpBuilder::buildSet(Expr *op, SourceLocation opcLoc,
1215                                            bool captureSetValueAsResult) {
1216   if (!findAtIndexSetter())
1217     return ExprError();
1218
1219   QualType receiverType = InstanceBase->getType();
1220   Expr *Index = InstanceKey;
1221
1222   // Arguments.
1223   Expr *args[] = { op, Index };
1224
1225   // Build a message-send.
1226   ExprResult msg = S.BuildInstanceMessageImplicit(InstanceBase, receiverType,
1227                                                   GenericLoc,
1228                                                   AtIndexSetterSelector,
1229                                                   AtIndexSetter,
1230                                                   MultiExprArg(args, 2));
1231
1232   if (!msg.isInvalid() && captureSetValueAsResult) {
1233     ObjCMessageExpr *msgExpr =
1234       cast<ObjCMessageExpr>(msg.get()->IgnoreImplicit());
1235     Expr *arg = msgExpr->getArg(0);
1236     msgExpr->setArg(0, captureValueAsResult(arg));
1237   }
1238
1239   return msg;
1240 }
1241
1242 //===----------------------------------------------------------------------===//
1243 //  General Sema routines.
1244 //===----------------------------------------------------------------------===//
1245
1246 ExprResult Sema::checkPseudoObjectRValue(Expr *E) {
1247   Expr *opaqueRef = E->IgnoreParens();
1248   if (ObjCPropertyRefExpr *refExpr
1249         = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1250     ObjCPropertyOpBuilder builder(*this, refExpr);
1251     return builder.buildRValueOperation(E);
1252   }
1253   else if (ObjCSubscriptRefExpr *refExpr
1254            = dyn_cast<ObjCSubscriptRefExpr>(opaqueRef)) {
1255     ObjCSubscriptOpBuilder builder(*this, refExpr);
1256     return builder.buildRValueOperation(E);
1257   } else {
1258     llvm_unreachable("unknown pseudo-object kind!");
1259   }
1260 }
1261
1262 /// Check an increment or decrement of a pseudo-object expression.
1263 ExprResult Sema::checkPseudoObjectIncDec(Scope *Sc, SourceLocation opcLoc,
1264                                          UnaryOperatorKind opcode, Expr *op) {
1265   // Do nothing if the operand is dependent.
1266   if (op->isTypeDependent())
1267     return new (Context) UnaryOperator(op, opcode, Context.DependentTy,
1268                                        VK_RValue, OK_Ordinary, opcLoc);
1269
1270   assert(UnaryOperator::isIncrementDecrementOp(opcode));
1271   Expr *opaqueRef = op->IgnoreParens();
1272   if (ObjCPropertyRefExpr *refExpr
1273         = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1274     ObjCPropertyOpBuilder builder(*this, refExpr);
1275     return builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1276   } else if (isa<ObjCSubscriptRefExpr>(opaqueRef)) {
1277     Diag(opcLoc, diag::err_illegal_container_subscripting_op);
1278     return ExprError();
1279   } else {
1280     llvm_unreachable("unknown pseudo-object kind!");
1281   }
1282 }
1283
1284 ExprResult Sema::checkPseudoObjectAssignment(Scope *S, SourceLocation opcLoc,
1285                                              BinaryOperatorKind opcode,
1286                                              Expr *LHS, Expr *RHS) {
1287   // Do nothing if either argument is dependent.
1288   if (LHS->isTypeDependent() || RHS->isTypeDependent())
1289     return new (Context) BinaryOperator(LHS, RHS, opcode, Context.DependentTy,
1290                                         VK_RValue, OK_Ordinary, opcLoc);
1291
1292   // Filter out non-overload placeholder types in the RHS.
1293   if (RHS->getType()->isNonOverloadPlaceholderType()) {
1294     ExprResult result = CheckPlaceholderExpr(RHS);
1295     if (result.isInvalid()) return ExprError();
1296     RHS = result.take();
1297   }
1298
1299   Expr *opaqueRef = LHS->IgnoreParens();
1300   if (ObjCPropertyRefExpr *refExpr
1301         = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1302     ObjCPropertyOpBuilder builder(*this, refExpr);
1303     return builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1304   } else if (ObjCSubscriptRefExpr *refExpr
1305              = dyn_cast<ObjCSubscriptRefExpr>(opaqueRef)) {
1306     ObjCSubscriptOpBuilder builder(*this, refExpr);
1307     return builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1308   } else {
1309     llvm_unreachable("unknown pseudo-object kind!");
1310   }
1311 }
1312
1313 /// Given a pseudo-object reference, rebuild it without the opaque
1314 /// values.  Basically, undo the behavior of rebuildAndCaptureObject.
1315 /// This should never operate in-place.
1316 static Expr *stripOpaqueValuesFromPseudoObjectRef(Sema &S, Expr *E) {
1317   Expr *opaqueRef = E->IgnoreParens();
1318   if (ObjCPropertyRefExpr *refExpr
1319         = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1320     // Class and super property references don't have opaque values in them.
1321     if (refExpr->isClassReceiver() || refExpr->isSuperReceiver())
1322       return E;
1323
1324     assert(refExpr->isObjectReceiver() && "Unknown receiver kind?");
1325     OpaqueValueExpr *baseOVE = cast<OpaqueValueExpr>(refExpr->getBase());
1326     return ObjCPropertyRefRebuilder(S, baseOVE->getSourceExpr()).rebuild(E);
1327   } else if (ObjCSubscriptRefExpr *refExpr
1328                = dyn_cast<ObjCSubscriptRefExpr>(opaqueRef)) {
1329     OpaqueValueExpr *baseOVE = cast<OpaqueValueExpr>(refExpr->getBaseExpr());
1330     OpaqueValueExpr *keyOVE = cast<OpaqueValueExpr>(refExpr->getKeyExpr());
1331     return ObjCSubscriptRefRebuilder(S, baseOVE->getSourceExpr(),
1332                                      keyOVE->getSourceExpr()).rebuild(E);
1333   } else {
1334     llvm_unreachable("unknown pseudo-object kind!");
1335   }
1336 }
1337
1338 /// Given a pseudo-object expression, recreate what it looks like
1339 /// syntactically without the attendant OpaqueValueExprs.
1340 ///
1341 /// This is a hack which should be removed when TreeTransform is
1342 /// capable of rebuilding a tree without stripping implicit
1343 /// operations.
1344 Expr *Sema::recreateSyntacticForm(PseudoObjectExpr *E) {
1345   Expr *syntax = E->getSyntacticForm();
1346   if (UnaryOperator *uop = dyn_cast<UnaryOperator>(syntax)) {
1347     Expr *op = stripOpaqueValuesFromPseudoObjectRef(*this, uop->getSubExpr());
1348     return new (Context) UnaryOperator(op, uop->getOpcode(), uop->getType(),
1349                                        uop->getValueKind(), uop->getObjectKind(),
1350                                        uop->getOperatorLoc());
1351   } else if (CompoundAssignOperator *cop
1352                = dyn_cast<CompoundAssignOperator>(syntax)) {
1353     Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, cop->getLHS());
1354     Expr *rhs = cast<OpaqueValueExpr>(cop->getRHS())->getSourceExpr();
1355     return new (Context) CompoundAssignOperator(lhs, rhs, cop->getOpcode(),
1356                                                 cop->getType(),
1357                                                 cop->getValueKind(),
1358                                                 cop->getObjectKind(),
1359                                                 cop->getComputationLHSType(),
1360                                                 cop->getComputationResultType(),
1361                                                 cop->getOperatorLoc());
1362   } else if (BinaryOperator *bop = dyn_cast<BinaryOperator>(syntax)) {
1363     Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, bop->getLHS());
1364     Expr *rhs = cast<OpaqueValueExpr>(bop->getRHS())->getSourceExpr();
1365     return new (Context) BinaryOperator(lhs, rhs, bop->getOpcode(),
1366                                         bop->getType(), bop->getValueKind(),
1367                                         bop->getObjectKind(),
1368                                         bop->getOperatorLoc());
1369   } else {
1370     assert(syntax->hasPlaceholderType(BuiltinType::PseudoObject));
1371     return stripOpaqueValuesFromPseudoObjectRef(*this, syntax);
1372   }
1373 }