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 } 1374