1 //===--- SemaPseudoObject.cpp - Semantic Analysis for Pseudo-Objects ------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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.
15 // For example, Objective-C objects can have "properties", either
16 // declared or undeclared. A property may be accessed by writing
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:
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]
31 //===----------------------------------------------------------------------===//
33 #include "clang/Sema/SemaInternal.h"
34 #include "clang/AST/ExprCXX.h"
35 #include "clang/AST/ExprObjC.h"
36 #include "clang/Basic/CharInfo.h"
37 #include "clang/Lex/Preprocessor.h"
38 #include "clang/Sema/Initialization.h"
39 #include "clang/Sema/ScopeInfo.h"
40 #include "llvm/ADT/SmallString.h"
42 using namespace clang;
46 // Basically just a very focused copy of TreeTransform.
47 template <class T> struct Rebuilder {
49 Rebuilder(Sema &S) : S(S) {}
51 T &getDerived() { return static_cast<T&>(*this); }
53 Expr *rebuild(Expr *e) {
54 // Fast path: nothing to look through.
55 if (typename T::specific_type *specific
56 = dyn_cast<typename T::specific_type>(e))
57 return getDerived().rebuildSpecific(specific);
59 // Otherwise, we should look through and rebuild anything that
60 // IgnoreParens would.
62 if (ParenExpr *parens = dyn_cast<ParenExpr>(e)) {
63 e = rebuild(parens->getSubExpr());
64 return new (S.Context) ParenExpr(parens->getLParen(),
69 if (UnaryOperator *uop = dyn_cast<UnaryOperator>(e)) {
70 assert(uop->getOpcode() == UO_Extension);
71 e = rebuild(uop->getSubExpr());
72 return new (S.Context) UnaryOperator(e, uop->getOpcode(),
76 uop->getOperatorLoc());
79 if (GenericSelectionExpr *gse = dyn_cast<GenericSelectionExpr>(e)) {
80 assert(!gse->isResultDependent());
81 unsigned resultIndex = gse->getResultIndex();
82 unsigned numAssocs = gse->getNumAssocs();
84 SmallVector<Expr*, 8> assocs(numAssocs);
85 SmallVector<TypeSourceInfo*, 8> assocTypes(numAssocs);
87 for (unsigned i = 0; i != numAssocs; ++i) {
88 Expr *assoc = gse->getAssocExpr(i);
89 if (i == resultIndex) assoc = rebuild(assoc);
91 assocTypes[i] = gse->getAssocTypeSourceInfo(i);
94 return new (S.Context) GenericSelectionExpr(S.Context,
96 gse->getControllingExpr(),
101 gse->containsUnexpandedParameterPack(),
105 if (ChooseExpr *ce = dyn_cast<ChooseExpr>(e)) {
106 assert(!ce->isConditionDependent());
108 Expr *LHS = ce->getLHS(), *RHS = ce->getRHS();
109 Expr *&rebuiltExpr = ce->isConditionTrue() ? LHS : RHS;
110 rebuiltExpr = rebuild(rebuiltExpr);
112 return new (S.Context) ChooseExpr(ce->getBuiltinLoc(),
115 rebuiltExpr->getType(),
116 rebuiltExpr->getValueKind(),
117 rebuiltExpr->getObjectKind(),
119 ce->isConditionTrue(),
120 rebuiltExpr->isTypeDependent(),
121 rebuiltExpr->isValueDependent());
124 llvm_unreachable("bad expression to rebuild!");
128 struct ObjCPropertyRefRebuilder : Rebuilder<ObjCPropertyRefRebuilder> {
130 ObjCPropertyRefRebuilder(Sema &S, Expr *newBase)
131 : Rebuilder<ObjCPropertyRefRebuilder>(S), NewBase(newBase) {}
133 typedef ObjCPropertyRefExpr specific_type;
134 Expr *rebuildSpecific(ObjCPropertyRefExpr *refExpr) {
135 // Fortunately, the constraint that we're rebuilding something
136 // with a base limits the number of cases here.
137 assert(refExpr->isObjectReceiver());
139 if (refExpr->isExplicitProperty()) {
140 return new (S.Context)
141 ObjCPropertyRefExpr(refExpr->getExplicitProperty(),
142 refExpr->getType(), refExpr->getValueKind(),
143 refExpr->getObjectKind(), refExpr->getLocation(),
146 return new (S.Context)
147 ObjCPropertyRefExpr(refExpr->getImplicitPropertyGetter(),
148 refExpr->getImplicitPropertySetter(),
149 refExpr->getType(), refExpr->getValueKind(),
150 refExpr->getObjectKind(),refExpr->getLocation(),
155 struct ObjCSubscriptRefRebuilder : Rebuilder<ObjCSubscriptRefRebuilder> {
158 ObjCSubscriptRefRebuilder(Sema &S, Expr *newBase, Expr *newKeyExpr)
159 : Rebuilder<ObjCSubscriptRefRebuilder>(S),
160 NewBase(newBase), NewKeyExpr(newKeyExpr) {}
162 typedef ObjCSubscriptRefExpr specific_type;
163 Expr *rebuildSpecific(ObjCSubscriptRefExpr *refExpr) {
164 assert(refExpr->getBaseExpr());
165 assert(refExpr->getKeyExpr());
167 return new (S.Context)
168 ObjCSubscriptRefExpr(NewBase,
170 refExpr->getType(), refExpr->getValueKind(),
171 refExpr->getObjectKind(),refExpr->getAtIndexMethodDecl(),
172 refExpr->setAtIndexMethodDecl(),
173 refExpr->getRBracket());
177 struct MSPropertyRefRebuilder : Rebuilder<MSPropertyRefRebuilder> {
179 MSPropertyRefRebuilder(Sema &S, Expr *newBase)
180 : Rebuilder<MSPropertyRefRebuilder>(S), NewBase(newBase) {}
182 typedef MSPropertyRefExpr specific_type;
183 Expr *rebuildSpecific(MSPropertyRefExpr *refExpr) {
184 assert(refExpr->getBaseExpr());
186 return new (S.Context)
187 MSPropertyRefExpr(NewBase, refExpr->getPropertyDecl(),
188 refExpr->isArrow(), refExpr->getType(),
189 refExpr->getValueKind(), refExpr->getQualifierLoc(),
190 refExpr->getMemberLoc());
194 class PseudoOpBuilder {
197 unsigned ResultIndex;
198 SourceLocation GenericLoc;
199 SmallVector<Expr *, 4> Semantics;
201 PseudoOpBuilder(Sema &S, SourceLocation genericLoc)
202 : S(S), ResultIndex(PseudoObjectExpr::NoResult),
203 GenericLoc(genericLoc) {}
205 virtual ~PseudoOpBuilder() {}
207 /// Add a normal semantic expression.
208 void addSemanticExpr(Expr *semantic) {
209 Semantics.push_back(semantic);
212 /// Add the 'result' semantic expression.
213 void addResultSemanticExpr(Expr *resultExpr) {
214 assert(ResultIndex == PseudoObjectExpr::NoResult);
215 ResultIndex = Semantics.size();
216 Semantics.push_back(resultExpr);
219 ExprResult buildRValueOperation(Expr *op);
220 ExprResult buildAssignmentOperation(Scope *Sc,
221 SourceLocation opLoc,
222 BinaryOperatorKind opcode,
223 Expr *LHS, Expr *RHS);
224 ExprResult buildIncDecOperation(Scope *Sc, SourceLocation opLoc,
225 UnaryOperatorKind opcode,
228 virtual ExprResult complete(Expr *syntacticForm);
230 OpaqueValueExpr *capture(Expr *op);
231 OpaqueValueExpr *captureValueAsResult(Expr *op);
233 void setResultToLastSemantic() {
234 assert(ResultIndex == PseudoObjectExpr::NoResult);
235 ResultIndex = Semantics.size() - 1;
238 /// Return true if assignments have a non-void result.
239 bool CanCaptureValue(Expr *exp) {
240 if (exp->isGLValue())
242 QualType ty = exp->getType();
243 assert(!ty->isIncompleteType());
244 assert(!ty->isDependentType());
246 if (const CXXRecordDecl *ClassDecl = ty->getAsCXXRecordDecl())
247 return ClassDecl->isTriviallyCopyable();
251 virtual Expr *rebuildAndCaptureObject(Expr *) = 0;
252 virtual ExprResult buildGet() = 0;
253 virtual ExprResult buildSet(Expr *, SourceLocation,
254 bool captureSetValueAsResult) = 0;
257 /// A PseudoOpBuilder for Objective-C \@properties.
258 class ObjCPropertyOpBuilder : public PseudoOpBuilder {
259 ObjCPropertyRefExpr *RefExpr;
260 ObjCPropertyRefExpr *SyntacticRefExpr;
261 OpaqueValueExpr *InstanceReceiver;
262 ObjCMethodDecl *Getter;
264 ObjCMethodDecl *Setter;
265 Selector SetterSelector;
266 Selector GetterSelector;
269 ObjCPropertyOpBuilder(Sema &S, ObjCPropertyRefExpr *refExpr) :
270 PseudoOpBuilder(S, refExpr->getLocation()), RefExpr(refExpr),
271 SyntacticRefExpr(nullptr), InstanceReceiver(nullptr), Getter(nullptr),
275 ExprResult buildRValueOperation(Expr *op);
276 ExprResult buildAssignmentOperation(Scope *Sc,
277 SourceLocation opLoc,
278 BinaryOperatorKind opcode,
279 Expr *LHS, Expr *RHS);
280 ExprResult buildIncDecOperation(Scope *Sc, SourceLocation opLoc,
281 UnaryOperatorKind opcode,
284 bool tryBuildGetOfReference(Expr *op, ExprResult &result);
285 bool findSetter(bool warn=true);
287 void DiagnoseUnsupportedPropertyUse();
289 Expr *rebuildAndCaptureObject(Expr *syntacticBase) override;
290 ExprResult buildGet() override;
291 ExprResult buildSet(Expr *op, SourceLocation, bool) override;
292 ExprResult complete(Expr *SyntacticForm) override;
294 bool isWeakProperty() const;
297 /// A PseudoOpBuilder for Objective-C array/dictionary indexing.
298 class ObjCSubscriptOpBuilder : public PseudoOpBuilder {
299 ObjCSubscriptRefExpr *RefExpr;
300 OpaqueValueExpr *InstanceBase;
301 OpaqueValueExpr *InstanceKey;
302 ObjCMethodDecl *AtIndexGetter;
303 Selector AtIndexGetterSelector;
305 ObjCMethodDecl *AtIndexSetter;
306 Selector AtIndexSetterSelector;
309 ObjCSubscriptOpBuilder(Sema &S, ObjCSubscriptRefExpr *refExpr) :
310 PseudoOpBuilder(S, refExpr->getSourceRange().getBegin()),
312 InstanceBase(nullptr), InstanceKey(nullptr),
313 AtIndexGetter(nullptr), AtIndexSetter(nullptr) {}
315 ExprResult buildRValueOperation(Expr *op);
316 ExprResult buildAssignmentOperation(Scope *Sc,
317 SourceLocation opLoc,
318 BinaryOperatorKind opcode,
319 Expr *LHS, Expr *RHS);
320 Expr *rebuildAndCaptureObject(Expr *syntacticBase) override;
322 bool findAtIndexGetter();
323 bool findAtIndexSetter();
325 ExprResult buildGet() override;
326 ExprResult buildSet(Expr *op, SourceLocation, bool) override;
329 class MSPropertyOpBuilder : public PseudoOpBuilder {
330 MSPropertyRefExpr *RefExpr;
333 MSPropertyOpBuilder(Sema &S, MSPropertyRefExpr *refExpr) :
334 PseudoOpBuilder(S, refExpr->getSourceRange().getBegin()),
337 Expr *rebuildAndCaptureObject(Expr *) override;
338 ExprResult buildGet() override;
339 ExprResult buildSet(Expr *op, SourceLocation, bool) override;
343 /// Capture the given expression in an OpaqueValueExpr.
344 OpaqueValueExpr *PseudoOpBuilder::capture(Expr *e) {
345 // Make a new OVE whose source is the given expression.
346 OpaqueValueExpr *captured =
347 new (S.Context) OpaqueValueExpr(GenericLoc, e->getType(),
348 e->getValueKind(), e->getObjectKind(),
351 // Make sure we bind that in the semantics.
352 addSemanticExpr(captured);
356 /// Capture the given expression as the result of this pseudo-object
357 /// operation. This routine is safe against expressions which may
358 /// already be captured.
360 /// \returns the captured expression, which will be the
361 /// same as the input if the input was already captured
362 OpaqueValueExpr *PseudoOpBuilder::captureValueAsResult(Expr *e) {
363 assert(ResultIndex == PseudoObjectExpr::NoResult);
365 // If the expression hasn't already been captured, just capture it
366 // and set the new semantic
367 if (!isa<OpaqueValueExpr>(e)) {
368 OpaqueValueExpr *cap = capture(e);
369 setResultToLastSemantic();
373 // Otherwise, it must already be one of our semantic expressions;
374 // set ResultIndex to its index.
377 assert(index < Semantics.size() &&
378 "captured expression not found in semantics!");
379 if (e == Semantics[index]) break;
382 return cast<OpaqueValueExpr>(e);
385 /// The routine which creates the final PseudoObjectExpr.
386 ExprResult PseudoOpBuilder::complete(Expr *syntactic) {
387 return PseudoObjectExpr::Create(S.Context, syntactic,
388 Semantics, ResultIndex);
391 /// The main skeleton for building an r-value operation.
392 ExprResult PseudoOpBuilder::buildRValueOperation(Expr *op) {
393 Expr *syntacticBase = rebuildAndCaptureObject(op);
395 ExprResult getExpr = buildGet();
396 if (getExpr.isInvalid()) return ExprError();
397 addResultSemanticExpr(getExpr.get());
399 return complete(syntacticBase);
402 /// The basic skeleton for building a simple or compound
403 /// assignment operation.
405 PseudoOpBuilder::buildAssignmentOperation(Scope *Sc, SourceLocation opcLoc,
406 BinaryOperatorKind opcode,
407 Expr *LHS, Expr *RHS) {
408 assert(BinaryOperator::isAssignmentOp(opcode));
410 // Recover from user error
411 if (isa<UnresolvedLookupExpr>(RHS))
414 Expr *syntacticLHS = rebuildAndCaptureObject(LHS);
415 OpaqueValueExpr *capturedRHS = capture(RHS);
420 if (opcode == BO_Assign) {
421 result = capturedRHS;
422 syntactic = new (S.Context) BinaryOperator(syntacticLHS, capturedRHS,
423 opcode, capturedRHS->getType(),
424 capturedRHS->getValueKind(),
425 OK_Ordinary, opcLoc, false);
427 ExprResult opLHS = buildGet();
428 if (opLHS.isInvalid()) return ExprError();
430 // Build an ordinary, non-compound operation.
431 BinaryOperatorKind nonCompound =
432 BinaryOperator::getOpForCompoundAssignment(opcode);
433 result = S.BuildBinOp(Sc, opcLoc, nonCompound,
434 opLHS.get(), capturedRHS);
435 if (result.isInvalid()) return ExprError();
438 new (S.Context) CompoundAssignOperator(syntacticLHS, capturedRHS, opcode,
439 result.get()->getType(),
440 result.get()->getValueKind(),
442 opLHS.get()->getType(),
443 result.get()->getType(),
447 // The result of the assignment, if not void, is the value set into
449 result = buildSet(result.get(), opcLoc, /*captureSetValueAsResult*/ true);
450 if (result.isInvalid()) return ExprError();
451 addSemanticExpr(result.get());
453 return complete(syntactic);
456 /// The basic skeleton for building an increment or decrement
459 PseudoOpBuilder::buildIncDecOperation(Scope *Sc, SourceLocation opcLoc,
460 UnaryOperatorKind opcode,
462 assert(UnaryOperator::isIncrementDecrementOp(opcode));
464 Expr *syntacticOp = rebuildAndCaptureObject(op);
467 ExprResult result = buildGet();
468 if (result.isInvalid()) return ExprError();
470 QualType resultType = result.get()->getType();
472 // That's the postfix result.
473 if (UnaryOperator::isPostfix(opcode) &&
474 (result.get()->isTypeDependent() || CanCaptureValue(result.get()))) {
475 result = capture(result.get());
476 setResultToLastSemantic();
479 // Add or subtract a literal 1.
480 llvm::APInt oneV(S.Context.getTypeSize(S.Context.IntTy), 1);
481 Expr *one = IntegerLiteral::Create(S.Context, oneV, S.Context.IntTy,
484 if (UnaryOperator::isIncrementOp(opcode)) {
485 result = S.BuildBinOp(Sc, opcLoc, BO_Add, result.get(), one);
487 result = S.BuildBinOp(Sc, opcLoc, BO_Sub, result.get(), one);
489 if (result.isInvalid()) return ExprError();
491 // Store that back into the result. The value stored is the result
492 // of a prefix operation.
493 result = buildSet(result.get(), opcLoc, UnaryOperator::isPrefix(opcode));
494 if (result.isInvalid()) return ExprError();
495 addSemanticExpr(result.get());
497 UnaryOperator *syntactic =
498 new (S.Context) UnaryOperator(syntacticOp, opcode, resultType,
499 VK_LValue, OK_Ordinary, opcLoc);
500 return complete(syntactic);
504 //===----------------------------------------------------------------------===//
505 // Objective-C @property and implicit property references
506 //===----------------------------------------------------------------------===//
508 /// Look up a method in the receiver type of an Objective-C property
510 static ObjCMethodDecl *LookupMethodInReceiverType(Sema &S, Selector sel,
511 const ObjCPropertyRefExpr *PRE) {
512 if (PRE->isObjectReceiver()) {
513 const ObjCObjectPointerType *PT =
514 PRE->getBase()->getType()->castAs<ObjCObjectPointerType>();
516 // Special case for 'self' in class method implementations.
517 if (PT->isObjCClassType() &&
518 S.isSelfExpr(const_cast<Expr*>(PRE->getBase()))) {
519 // This cast is safe because isSelfExpr is only true within
521 ObjCMethodDecl *method =
522 cast<ObjCMethodDecl>(S.CurContext->getNonClosureAncestor());
523 return S.LookupMethodInObjectType(sel,
524 S.Context.getObjCInterfaceType(method->getClassInterface()),
528 return S.LookupMethodInObjectType(sel, PT->getPointeeType(), true);
531 if (PRE->isSuperReceiver()) {
532 if (const ObjCObjectPointerType *PT =
533 PRE->getSuperReceiverType()->getAs<ObjCObjectPointerType>())
534 return S.LookupMethodInObjectType(sel, PT->getPointeeType(), true);
536 return S.LookupMethodInObjectType(sel, PRE->getSuperReceiverType(), false);
539 assert(PRE->isClassReceiver() && "Invalid expression");
540 QualType IT = S.Context.getObjCInterfaceType(PRE->getClassReceiver());
541 return S.LookupMethodInObjectType(sel, IT, false);
544 bool ObjCPropertyOpBuilder::isWeakProperty() const {
546 if (RefExpr->isExplicitProperty()) {
547 const ObjCPropertyDecl *Prop = RefExpr->getExplicitProperty();
548 if (Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak)
549 return !Prop->hasAttr<IBOutletAttr>();
553 T = Getter->getReturnType();
558 return T.getObjCLifetime() == Qualifiers::OCL_Weak;
561 bool ObjCPropertyOpBuilder::findGetter() {
562 if (Getter) return true;
564 // For implicit properties, just trust the lookup we already did.
565 if (RefExpr->isImplicitProperty()) {
566 if ((Getter = RefExpr->getImplicitPropertyGetter())) {
567 GetterSelector = Getter->getSelector();
571 // Must build the getter selector the hard way.
572 ObjCMethodDecl *setter = RefExpr->getImplicitPropertySetter();
573 assert(setter && "both setter and getter are null - cannot happen");
574 IdentifierInfo *setterName =
575 setter->getSelector().getIdentifierInfoForSlot(0);
576 IdentifierInfo *getterName =
577 &S.Context.Idents.get(setterName->getName().substr(3));
579 S.PP.getSelectorTable().getNullarySelector(getterName);
584 ObjCPropertyDecl *prop = RefExpr->getExplicitProperty();
585 Getter = LookupMethodInReceiverType(S, prop->getGetterName(), RefExpr);
586 return (Getter != nullptr);
589 /// Try to find the most accurate setter declaration for the property
592 /// \return true if a setter was found, in which case Setter
593 bool ObjCPropertyOpBuilder::findSetter(bool warn) {
594 // For implicit properties, just trust the lookup we already did.
595 if (RefExpr->isImplicitProperty()) {
596 if (ObjCMethodDecl *setter = RefExpr->getImplicitPropertySetter()) {
598 SetterSelector = setter->getSelector();
601 IdentifierInfo *getterName =
602 RefExpr->getImplicitPropertyGetter()->getSelector()
603 .getIdentifierInfoForSlot(0);
605 SelectorTable::constructSetterSelector(S.PP.getIdentifierTable(),
606 S.PP.getSelectorTable(),
612 // For explicit properties, this is more involved.
613 ObjCPropertyDecl *prop = RefExpr->getExplicitProperty();
614 SetterSelector = prop->getSetterName();
616 // Do a normal method lookup first.
617 if (ObjCMethodDecl *setter =
618 LookupMethodInReceiverType(S, SetterSelector, RefExpr)) {
619 if (setter->isPropertyAccessor() && warn)
620 if (const ObjCInterfaceDecl *IFace =
621 dyn_cast<ObjCInterfaceDecl>(setter->getDeclContext())) {
622 StringRef thisPropertyName = prop->getName();
623 // Try flipping the case of the first character.
624 char front = thisPropertyName.front();
625 front = isLowercase(front) ? toUppercase(front) : toLowercase(front);
626 SmallString<100> PropertyName = thisPropertyName;
627 PropertyName[0] = front;
628 IdentifierInfo *AltMember = &S.PP.getIdentifierTable().get(PropertyName);
629 if (ObjCPropertyDecl *prop1 = IFace->FindPropertyDeclaration(AltMember))
630 if (prop != prop1 && (prop1->getSetterMethodDecl() == setter)) {
631 S.Diag(RefExpr->getExprLoc(), diag::error_property_setter_ambiguous_use)
632 << prop << prop1 << setter->getSelector();
633 S.Diag(prop->getLocation(), diag::note_property_declare);
634 S.Diag(prop1->getLocation(), diag::note_property_declare);
641 // That can fail in the somewhat crazy situation that we're
642 // type-checking a message send within the @interface declaration
643 // that declared the @property. But it's not clear that that's
644 // valuable to support.
649 void ObjCPropertyOpBuilder::DiagnoseUnsupportedPropertyUse() {
650 if (S.getCurLexicalContext()->isObjCContainer() &&
651 S.getCurLexicalContext()->getDeclKind() != Decl::ObjCCategoryImpl &&
652 S.getCurLexicalContext()->getDeclKind() != Decl::ObjCImplementation) {
653 if (ObjCPropertyDecl *prop = RefExpr->getExplicitProperty()) {
654 S.Diag(RefExpr->getLocation(),
655 diag::err_property_function_in_objc_container);
656 S.Diag(prop->getLocation(), diag::note_property_declare);
661 /// Capture the base object of an Objective-C property expression.
662 Expr *ObjCPropertyOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
663 assert(InstanceReceiver == nullptr);
665 // If we have a base, capture it in an OVE and rebuild the syntactic
666 // form to use the OVE as its base.
667 if (RefExpr->isObjectReceiver()) {
668 InstanceReceiver = capture(RefExpr->getBase());
671 ObjCPropertyRefRebuilder(S, InstanceReceiver).rebuild(syntacticBase);
674 if (ObjCPropertyRefExpr *
675 refE = dyn_cast<ObjCPropertyRefExpr>(syntacticBase->IgnoreParens()))
676 SyntacticRefExpr = refE;
678 return syntacticBase;
681 /// Load from an Objective-C property reference.
682 ExprResult ObjCPropertyOpBuilder::buildGet() {
685 DiagnoseUnsupportedPropertyUse();
689 if (SyntacticRefExpr)
690 SyntacticRefExpr->setIsMessagingGetter();
692 QualType receiverType;
693 if (RefExpr->isClassReceiver()) {
694 receiverType = S.Context.getObjCInterfaceType(RefExpr->getClassReceiver());
695 } else if (RefExpr->isSuperReceiver()) {
696 receiverType = RefExpr->getSuperReceiverType();
698 assert(InstanceReceiver);
699 receiverType = InstanceReceiver->getType();
701 if (!Getter->isImplicit())
702 S.DiagnoseUseOfDecl(Getter, GenericLoc, nullptr, true);
703 // Build a message-send.
705 if ((Getter->isInstanceMethod() && !RefExpr->isClassReceiver()) ||
706 RefExpr->isObjectReceiver()) {
707 assert(InstanceReceiver || RefExpr->isSuperReceiver());
708 msg = S.BuildInstanceMessageImplicit(InstanceReceiver, receiverType,
709 GenericLoc, Getter->getSelector(),
712 msg = S.BuildClassMessageImplicit(receiverType, RefExpr->isSuperReceiver(),
713 GenericLoc, Getter->getSelector(),
719 /// Store to an Objective-C property reference.
721 /// \param captureSetValueAsResult If true, capture the actual
722 /// value being set as the value of the property operation.
723 ExprResult ObjCPropertyOpBuilder::buildSet(Expr *op, SourceLocation opcLoc,
724 bool captureSetValueAsResult) {
725 if (!findSetter(false)) {
726 DiagnoseUnsupportedPropertyUse();
730 if (SyntacticRefExpr)
731 SyntacticRefExpr->setIsMessagingSetter();
733 QualType receiverType;
734 if (RefExpr->isClassReceiver()) {
735 receiverType = S.Context.getObjCInterfaceType(RefExpr->getClassReceiver());
736 } else if (RefExpr->isSuperReceiver()) {
737 receiverType = RefExpr->getSuperReceiverType();
739 assert(InstanceReceiver);
740 receiverType = InstanceReceiver->getType();
743 // Use assignment constraints when possible; they give us better
744 // diagnostics. "When possible" basically means anything except a
746 if (!S.getLangOpts().CPlusPlus || !op->getType()->isRecordType()) {
747 QualType paramType = (*Setter->param_begin())->getType();
748 if (!S.getLangOpts().CPlusPlus || !paramType->isRecordType()) {
749 ExprResult opResult = op;
750 Sema::AssignConvertType assignResult
751 = S.CheckSingleAssignmentConstraints(paramType, opResult);
752 if (S.DiagnoseAssignmentResult(assignResult, opcLoc, paramType,
753 op->getType(), opResult.get(),
758 assert(op && "successful assignment left argument invalid?");
760 else if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(op)) {
761 Expr *Initializer = OVE->getSourceExpr();
762 // passing C++11 style initialized temporaries to objc++ properties
763 // requires special treatment by removing OpaqueValueExpr so type
764 // conversion takes place and adding the OpaqueValueExpr later on.
765 if (isa<InitListExpr>(Initializer) &&
766 Initializer->getType()->isVoidType()) {
773 Expr *args[] = { op };
775 // Build a message-send.
777 if (!Setter->isImplicit())
778 S.DiagnoseUseOfDecl(Setter, GenericLoc, nullptr, true);
779 if ((Setter->isInstanceMethod() && !RefExpr->isClassReceiver()) ||
780 RefExpr->isObjectReceiver()) {
781 msg = S.BuildInstanceMessageImplicit(InstanceReceiver, receiverType,
782 GenericLoc, SetterSelector, Setter,
783 MultiExprArg(args, 1));
785 msg = S.BuildClassMessageImplicit(receiverType, RefExpr->isSuperReceiver(),
787 SetterSelector, Setter,
788 MultiExprArg(args, 1));
791 if (!msg.isInvalid() && captureSetValueAsResult) {
792 ObjCMessageExpr *msgExpr =
793 cast<ObjCMessageExpr>(msg.get()->IgnoreImplicit());
794 Expr *arg = msgExpr->getArg(0);
795 if (CanCaptureValue(arg))
796 msgExpr->setArg(0, captureValueAsResult(arg));
802 /// @property-specific behavior for doing lvalue-to-rvalue conversion.
803 ExprResult ObjCPropertyOpBuilder::buildRValueOperation(Expr *op) {
804 // Explicit properties always have getters, but implicit ones don't.
805 // Check that before proceeding.
806 if (RefExpr->isImplicitProperty() && !RefExpr->getImplicitPropertyGetter()) {
807 S.Diag(RefExpr->getLocation(), diag::err_getter_not_found)
808 << RefExpr->getSourceRange();
812 ExprResult result = PseudoOpBuilder::buildRValueOperation(op);
813 if (result.isInvalid()) return ExprError();
815 if (RefExpr->isExplicitProperty() && !Getter->hasRelatedResultType())
816 S.DiagnosePropertyAccessorMismatch(RefExpr->getExplicitProperty(),
817 Getter, RefExpr->getLocation());
819 // As a special case, if the method returns 'id', try to get
820 // a better type from the property.
821 if (RefExpr->isExplicitProperty() && result.get()->isRValue()) {
822 QualType propType = RefExpr->getExplicitProperty()->getType();
823 if (result.get()->getType()->isObjCIdType()) {
824 if (const ObjCObjectPointerType *ptr
825 = propType->getAs<ObjCObjectPointerType>()) {
826 if (!ptr->isObjCIdType())
827 result = S.ImpCastExprToType(result.get(), propType, CK_BitCast);
830 if (S.getLangOpts().ObjCAutoRefCount) {
831 Qualifiers::ObjCLifetime LT = propType.getObjCLifetime();
832 if (LT == Qualifiers::OCL_Weak)
833 if (!S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, RefExpr->getLocation()))
834 S.getCurFunction()->markSafeWeakUse(RefExpr);
841 /// Try to build this as a call to a getter that returns a reference.
843 /// \return true if it was possible, whether or not it actually
845 bool ObjCPropertyOpBuilder::tryBuildGetOfReference(Expr *op,
846 ExprResult &result) {
847 if (!S.getLangOpts().CPlusPlus) return false;
851 // The property has no setter and no getter! This can happen if the type is
852 // invalid. Error have already been reported.
853 result = ExprError();
857 // Only do this if the getter returns an l-value reference type.
858 QualType resultType = Getter->getReturnType();
859 if (!resultType->isLValueReferenceType()) return false;
861 result = buildRValueOperation(op);
865 /// @property-specific behavior for doing assignments.
867 ObjCPropertyOpBuilder::buildAssignmentOperation(Scope *Sc,
868 SourceLocation opcLoc,
869 BinaryOperatorKind opcode,
870 Expr *LHS, Expr *RHS) {
871 assert(BinaryOperator::isAssignmentOp(opcode));
873 // If there's no setter, we have no choice but to try to assign to
874 // the result of the getter.
877 if (tryBuildGetOfReference(LHS, result)) {
878 if (result.isInvalid()) return ExprError();
879 return S.BuildBinOp(Sc, opcLoc, opcode, result.get(), RHS);
882 // Otherwise, it's an error.
883 S.Diag(opcLoc, diag::err_nosetter_property_assignment)
884 << unsigned(RefExpr->isImplicitProperty())
886 << LHS->getSourceRange() << RHS->getSourceRange();
890 // If there is a setter, we definitely want to use it.
892 // Verify that we can do a compound assignment.
893 if (opcode != BO_Assign && !findGetter()) {
894 S.Diag(opcLoc, diag::err_nogetter_property_compound_assignment)
895 << LHS->getSourceRange() << RHS->getSourceRange();
900 PseudoOpBuilder::buildAssignmentOperation(Sc, opcLoc, opcode, LHS, RHS);
901 if (result.isInvalid()) return ExprError();
903 // Various warnings about property assignments in ARC.
904 if (S.getLangOpts().ObjCAutoRefCount && InstanceReceiver) {
905 S.checkRetainCycles(InstanceReceiver->getSourceExpr(), RHS);
906 S.checkUnsafeExprAssigns(opcLoc, LHS, RHS);
912 /// @property-specific behavior for doing increments and decrements.
914 ObjCPropertyOpBuilder::buildIncDecOperation(Scope *Sc, SourceLocation opcLoc,
915 UnaryOperatorKind opcode,
917 // If there's no setter, we have no choice but to try to assign to
918 // the result of the getter.
921 if (tryBuildGetOfReference(op, result)) {
922 if (result.isInvalid()) return ExprError();
923 return S.BuildUnaryOp(Sc, opcLoc, opcode, result.get());
926 // Otherwise, it's an error.
927 S.Diag(opcLoc, diag::err_nosetter_property_incdec)
928 << unsigned(RefExpr->isImplicitProperty())
929 << unsigned(UnaryOperator::isDecrementOp(opcode))
931 << op->getSourceRange();
935 // If there is a setter, we definitely want to use it.
937 // We also need a getter.
939 assert(RefExpr->isImplicitProperty());
940 S.Diag(opcLoc, diag::err_nogetter_property_incdec)
941 << unsigned(UnaryOperator::isDecrementOp(opcode))
943 << op->getSourceRange();
947 return PseudoOpBuilder::buildIncDecOperation(Sc, opcLoc, opcode, op);
950 ExprResult ObjCPropertyOpBuilder::complete(Expr *SyntacticForm) {
951 if (S.getLangOpts().ObjCAutoRefCount && isWeakProperty() &&
952 !S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak,
953 SyntacticForm->getLocStart()))
954 S.recordUseOfEvaluatedWeak(SyntacticRefExpr,
955 SyntacticRefExpr->isMessagingGetter());
957 return PseudoOpBuilder::complete(SyntacticForm);
960 // ObjCSubscript build stuff.
963 /// objective-c subscripting-specific behavior for doing lvalue-to-rvalue
965 /// FIXME. Remove this routine if it is proven that no additional
966 /// specifity is needed.
967 ExprResult ObjCSubscriptOpBuilder::buildRValueOperation(Expr *op) {
968 ExprResult result = PseudoOpBuilder::buildRValueOperation(op);
969 if (result.isInvalid()) return ExprError();
973 /// objective-c subscripting-specific behavior for doing assignments.
975 ObjCSubscriptOpBuilder::buildAssignmentOperation(Scope *Sc,
976 SourceLocation opcLoc,
977 BinaryOperatorKind opcode,
978 Expr *LHS, Expr *RHS) {
979 assert(BinaryOperator::isAssignmentOp(opcode));
980 // There must be a method to do the Index'ed assignment.
981 if (!findAtIndexSetter())
984 // Verify that we can do a compound assignment.
985 if (opcode != BO_Assign && !findAtIndexGetter())
989 PseudoOpBuilder::buildAssignmentOperation(Sc, opcLoc, opcode, LHS, RHS);
990 if (result.isInvalid()) return ExprError();
992 // Various warnings about objc Index'ed assignments in ARC.
993 if (S.getLangOpts().ObjCAutoRefCount && InstanceBase) {
994 S.checkRetainCycles(InstanceBase->getSourceExpr(), RHS);
995 S.checkUnsafeExprAssigns(opcLoc, LHS, RHS);
1001 /// Capture the base object of an Objective-C Index'ed expression.
1002 Expr *ObjCSubscriptOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
1003 assert(InstanceBase == nullptr);
1005 // Capture base expression in an OVE and rebuild the syntactic
1006 // form to use the OVE as its base expression.
1007 InstanceBase = capture(RefExpr->getBaseExpr());
1008 InstanceKey = capture(RefExpr->getKeyExpr());
1011 ObjCSubscriptRefRebuilder(S, InstanceBase,
1012 InstanceKey).rebuild(syntacticBase);
1014 return syntacticBase;
1017 /// CheckSubscriptingKind - This routine decide what type
1018 /// of indexing represented by "FromE" is being done.
1019 Sema::ObjCSubscriptKind
1020 Sema::CheckSubscriptingKind(Expr *FromE) {
1021 // If the expression already has integral or enumeration type, we're golden.
1022 QualType T = FromE->getType();
1023 if (T->isIntegralOrEnumerationType())
1026 // If we don't have a class type in C++, there's no way we can get an
1027 // expression of integral or enumeration type.
1028 const RecordType *RecordTy = T->getAs<RecordType>();
1030 (T->isObjCObjectPointerType() || T->isVoidPointerType()))
1031 // All other scalar cases are assumed to be dictionary indexing which
1032 // caller handles, with diagnostics if needed.
1033 return OS_Dictionary;
1034 if (!getLangOpts().CPlusPlus ||
1035 !RecordTy || RecordTy->isIncompleteType()) {
1036 // No indexing can be done. Issue diagnostics and quit.
1037 const Expr *IndexExpr = FromE->IgnoreParenImpCasts();
1038 if (isa<StringLiteral>(IndexExpr))
1039 Diag(FromE->getExprLoc(), diag::err_objc_subscript_pointer)
1040 << T << FixItHint::CreateInsertion(FromE->getExprLoc(), "@");
1042 Diag(FromE->getExprLoc(), diag::err_objc_subscript_type_conversion)
1047 // We must have a complete class type.
1048 if (RequireCompleteType(FromE->getExprLoc(), T,
1049 diag::err_objc_index_incomplete_class_type, FromE))
1052 // Look for a conversion to an integral, enumeration type, or
1053 // objective-C pointer type.
1054 std::pair<CXXRecordDecl::conversion_iterator,
1055 CXXRecordDecl::conversion_iterator> Conversions
1056 = cast<CXXRecordDecl>(RecordTy->getDecl())->getVisibleConversionFunctions();
1058 int NoIntegrals=0, NoObjCIdPointers=0;
1059 SmallVector<CXXConversionDecl *, 4> ConversionDecls;
1061 for (CXXRecordDecl::conversion_iterator
1062 I = Conversions.first, E = Conversions.second; I != E; ++I) {
1063 if (CXXConversionDecl *Conversion
1064 = dyn_cast<CXXConversionDecl>((*I)->getUnderlyingDecl())) {
1065 QualType CT = Conversion->getConversionType().getNonReferenceType();
1066 if (CT->isIntegralOrEnumerationType()) {
1068 ConversionDecls.push_back(Conversion);
1070 else if (CT->isObjCIdType() ||CT->isBlockPointerType()) {
1072 ConversionDecls.push_back(Conversion);
1076 if (NoIntegrals ==1 && NoObjCIdPointers == 0)
1078 if (NoIntegrals == 0 && NoObjCIdPointers == 1)
1079 return OS_Dictionary;
1080 if (NoIntegrals == 0 && NoObjCIdPointers == 0) {
1081 // No conversion function was found. Issue diagnostic and return.
1082 Diag(FromE->getExprLoc(), diag::err_objc_subscript_type_conversion)
1083 << FromE->getType();
1086 Diag(FromE->getExprLoc(), diag::err_objc_multiple_subscript_type_conversion)
1087 << FromE->getType();
1088 for (unsigned int i = 0; i < ConversionDecls.size(); i++)
1089 Diag(ConversionDecls[i]->getLocation(), diag::not_conv_function_declared_at);
1094 /// CheckKeyForObjCARCConversion - This routine suggests bridge casting of CF
1095 /// objects used as dictionary subscript key objects.
1096 static void CheckKeyForObjCARCConversion(Sema &S, QualType ContainerT,
1098 if (ContainerT.isNull())
1100 // dictionary subscripting.
1101 // - (id)objectForKeyedSubscript:(id)key;
1102 IdentifierInfo *KeyIdents[] = {
1103 &S.Context.Idents.get("objectForKeyedSubscript")
1105 Selector GetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
1106 ObjCMethodDecl *Getter = S.LookupMethodInObjectType(GetterSelector, ContainerT,
1110 QualType T = Getter->parameters()[0]->getType();
1111 S.CheckObjCARCConversion(Key->getSourceRange(),
1112 T, Key, Sema::CCK_ImplicitConversion);
1115 bool ObjCSubscriptOpBuilder::findAtIndexGetter() {
1119 Expr *BaseExpr = RefExpr->getBaseExpr();
1120 QualType BaseT = BaseExpr->getType();
1122 QualType ResultType;
1123 if (const ObjCObjectPointerType *PTy =
1124 BaseT->getAs<ObjCObjectPointerType>()) {
1125 ResultType = PTy->getPointeeType();
1126 if (const ObjCObjectType *iQFaceTy =
1127 ResultType->getAsObjCQualifiedInterfaceType())
1128 ResultType = iQFaceTy->getBaseType();
1130 Sema::ObjCSubscriptKind Res =
1131 S.CheckSubscriptingKind(RefExpr->getKeyExpr());
1132 if (Res == Sema::OS_Error) {
1133 if (S.getLangOpts().ObjCAutoRefCount)
1134 CheckKeyForObjCARCConversion(S, ResultType,
1135 RefExpr->getKeyExpr());
1138 bool arrayRef = (Res == Sema::OS_Array);
1140 if (ResultType.isNull()) {
1141 S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_base_type)
1142 << BaseExpr->getType() << arrayRef;
1146 // dictionary subscripting.
1147 // - (id)objectForKeyedSubscript:(id)key;
1148 IdentifierInfo *KeyIdents[] = {
1149 &S.Context.Idents.get("objectForKeyedSubscript")
1151 AtIndexGetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
1154 // - (id)objectAtIndexedSubscript:(size_t)index;
1155 IdentifierInfo *KeyIdents[] = {
1156 &S.Context.Idents.get("objectAtIndexedSubscript")
1159 AtIndexGetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
1162 AtIndexGetter = S.LookupMethodInObjectType(AtIndexGetterSelector, ResultType,
1164 bool receiverIdType = (BaseT->isObjCIdType() ||
1165 BaseT->isObjCQualifiedIdType());
1167 if (!AtIndexGetter && S.getLangOpts().DebuggerObjCLiteral) {
1168 AtIndexGetter = ObjCMethodDecl::Create(S.Context, SourceLocation(),
1169 SourceLocation(), AtIndexGetterSelector,
1170 S.Context.getObjCIdType() /*ReturnType*/,
1171 nullptr /*TypeSourceInfo */,
1172 S.Context.getTranslationUnitDecl(),
1173 true /*Instance*/, false/*isVariadic*/,
1174 /*isPropertyAccessor=*/false,
1175 /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
1176 ObjCMethodDecl::Required,
1178 ParmVarDecl *Argument = ParmVarDecl::Create(S.Context, AtIndexGetter,
1179 SourceLocation(), SourceLocation(),
1180 arrayRef ? &S.Context.Idents.get("index")
1181 : &S.Context.Idents.get("key"),
1182 arrayRef ? S.Context.UnsignedLongTy
1183 : S.Context.getObjCIdType(),
1187 AtIndexGetter->setMethodParams(S.Context, Argument, None);
1190 if (!AtIndexGetter) {
1191 if (!receiverIdType) {
1192 S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_method_not_found)
1193 << BaseExpr->getType() << 0 << arrayRef;
1197 S.LookupInstanceMethodInGlobalPool(AtIndexGetterSelector,
1198 RefExpr->getSourceRange(),
1202 if (AtIndexGetter) {
1203 QualType T = AtIndexGetter->parameters()[0]->getType();
1204 if ((arrayRef && !T->isIntegralOrEnumerationType()) ||
1205 (!arrayRef && !T->isObjCObjectPointerType())) {
1206 S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1207 arrayRef ? diag::err_objc_subscript_index_type
1208 : diag::err_objc_subscript_key_type) << T;
1209 S.Diag(AtIndexGetter->parameters()[0]->getLocation(),
1210 diag::note_parameter_type) << T;
1213 QualType R = AtIndexGetter->getReturnType();
1214 if (!R->isObjCObjectPointerType()) {
1215 S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1216 diag::err_objc_indexing_method_result_type) << R << arrayRef;
1217 S.Diag(AtIndexGetter->getLocation(), diag::note_method_declared_at) <<
1218 AtIndexGetter->getDeclName();
1224 bool ObjCSubscriptOpBuilder::findAtIndexSetter() {
1228 Expr *BaseExpr = RefExpr->getBaseExpr();
1229 QualType BaseT = BaseExpr->getType();
1231 QualType ResultType;
1232 if (const ObjCObjectPointerType *PTy =
1233 BaseT->getAs<ObjCObjectPointerType>()) {
1234 ResultType = PTy->getPointeeType();
1235 if (const ObjCObjectType *iQFaceTy =
1236 ResultType->getAsObjCQualifiedInterfaceType())
1237 ResultType = iQFaceTy->getBaseType();
1240 Sema::ObjCSubscriptKind Res =
1241 S.CheckSubscriptingKind(RefExpr->getKeyExpr());
1242 if (Res == Sema::OS_Error) {
1243 if (S.getLangOpts().ObjCAutoRefCount)
1244 CheckKeyForObjCARCConversion(S, ResultType,
1245 RefExpr->getKeyExpr());
1248 bool arrayRef = (Res == Sema::OS_Array);
1250 if (ResultType.isNull()) {
1251 S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_base_type)
1252 << BaseExpr->getType() << arrayRef;
1257 // dictionary subscripting.
1258 // - (void)setObject:(id)object forKeyedSubscript:(id)key;
1259 IdentifierInfo *KeyIdents[] = {
1260 &S.Context.Idents.get("setObject"),
1261 &S.Context.Idents.get("forKeyedSubscript")
1263 AtIndexSetterSelector = S.Context.Selectors.getSelector(2, KeyIdents);
1266 // - (void)setObject:(id)object atIndexedSubscript:(NSInteger)index;
1267 IdentifierInfo *KeyIdents[] = {
1268 &S.Context.Idents.get("setObject"),
1269 &S.Context.Idents.get("atIndexedSubscript")
1271 AtIndexSetterSelector = S.Context.Selectors.getSelector(2, KeyIdents);
1273 AtIndexSetter = S.LookupMethodInObjectType(AtIndexSetterSelector, ResultType,
1276 bool receiverIdType = (BaseT->isObjCIdType() ||
1277 BaseT->isObjCQualifiedIdType());
1279 if (!AtIndexSetter && S.getLangOpts().DebuggerObjCLiteral) {
1280 TypeSourceInfo *ReturnTInfo = nullptr;
1281 QualType ReturnType = S.Context.VoidTy;
1282 AtIndexSetter = ObjCMethodDecl::Create(
1283 S.Context, SourceLocation(), SourceLocation(), AtIndexSetterSelector,
1284 ReturnType, ReturnTInfo, S.Context.getTranslationUnitDecl(),
1285 true /*Instance*/, false /*isVariadic*/,
1286 /*isPropertyAccessor=*/false,
1287 /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
1288 ObjCMethodDecl::Required, false);
1289 SmallVector<ParmVarDecl *, 2> Params;
1290 ParmVarDecl *object = ParmVarDecl::Create(S.Context, AtIndexSetter,
1291 SourceLocation(), SourceLocation(),
1292 &S.Context.Idents.get("object"),
1293 S.Context.getObjCIdType(),
1297 Params.push_back(object);
1298 ParmVarDecl *key = ParmVarDecl::Create(S.Context, AtIndexSetter,
1299 SourceLocation(), SourceLocation(),
1300 arrayRef ? &S.Context.Idents.get("index")
1301 : &S.Context.Idents.get("key"),
1302 arrayRef ? S.Context.UnsignedLongTy
1303 : S.Context.getObjCIdType(),
1307 Params.push_back(key);
1308 AtIndexSetter->setMethodParams(S.Context, Params, None);
1311 if (!AtIndexSetter) {
1312 if (!receiverIdType) {
1313 S.Diag(BaseExpr->getExprLoc(),
1314 diag::err_objc_subscript_method_not_found)
1315 << BaseExpr->getType() << 1 << arrayRef;
1319 S.LookupInstanceMethodInGlobalPool(AtIndexSetterSelector,
1320 RefExpr->getSourceRange(),
1325 if (AtIndexSetter && arrayRef) {
1326 QualType T = AtIndexSetter->parameters()[1]->getType();
1327 if (!T->isIntegralOrEnumerationType()) {
1328 S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1329 diag::err_objc_subscript_index_type) << T;
1330 S.Diag(AtIndexSetter->parameters()[1]->getLocation(),
1331 diag::note_parameter_type) << T;
1334 T = AtIndexSetter->parameters()[0]->getType();
1335 if (!T->isObjCObjectPointerType()) {
1336 S.Diag(RefExpr->getBaseExpr()->getExprLoc(),
1337 diag::err_objc_subscript_object_type) << T << arrayRef;
1338 S.Diag(AtIndexSetter->parameters()[0]->getLocation(),
1339 diag::note_parameter_type) << T;
1343 else if (AtIndexSetter && !arrayRef)
1344 for (unsigned i=0; i <2; i++) {
1345 QualType T = AtIndexSetter->parameters()[i]->getType();
1346 if (!T->isObjCObjectPointerType()) {
1348 S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1349 diag::err_objc_subscript_key_type) << T;
1351 S.Diag(RefExpr->getBaseExpr()->getExprLoc(),
1352 diag::err_objc_subscript_dic_object_type) << T;
1353 S.Diag(AtIndexSetter->parameters()[i]->getLocation(),
1354 diag::note_parameter_type) << T;
1362 // Get the object at "Index" position in the container.
1363 // [BaseExpr objectAtIndexedSubscript : IndexExpr];
1364 ExprResult ObjCSubscriptOpBuilder::buildGet() {
1365 if (!findAtIndexGetter())
1368 QualType receiverType = InstanceBase->getType();
1370 // Build a message-send.
1372 Expr *Index = InstanceKey;
1375 Expr *args[] = { Index };
1376 assert(InstanceBase);
1378 S.DiagnoseUseOfDecl(AtIndexGetter, GenericLoc);
1379 msg = S.BuildInstanceMessageImplicit(InstanceBase, receiverType,
1381 AtIndexGetterSelector, AtIndexGetter,
1382 MultiExprArg(args, 1));
1386 /// Store into the container the "op" object at "Index"'ed location
1387 /// by building this messaging expression:
1388 /// - (void)setObject:(id)object atIndexedSubscript:(NSInteger)index;
1389 /// \param captureSetValueAsResult If true, capture the actual
1390 /// value being set as the value of the property operation.
1391 ExprResult ObjCSubscriptOpBuilder::buildSet(Expr *op, SourceLocation opcLoc,
1392 bool captureSetValueAsResult) {
1393 if (!findAtIndexSetter())
1396 S.DiagnoseUseOfDecl(AtIndexSetter, GenericLoc);
1397 QualType receiverType = InstanceBase->getType();
1398 Expr *Index = InstanceKey;
1401 Expr *args[] = { op, Index };
1403 // Build a message-send.
1404 ExprResult msg = S.BuildInstanceMessageImplicit(InstanceBase, receiverType,
1406 AtIndexSetterSelector,
1408 MultiExprArg(args, 2));
1410 if (!msg.isInvalid() && captureSetValueAsResult) {
1411 ObjCMessageExpr *msgExpr =
1412 cast<ObjCMessageExpr>(msg.get()->IgnoreImplicit());
1413 Expr *arg = msgExpr->getArg(0);
1414 if (CanCaptureValue(arg))
1415 msgExpr->setArg(0, captureValueAsResult(arg));
1421 //===----------------------------------------------------------------------===//
1422 // MSVC __declspec(property) references
1423 //===----------------------------------------------------------------------===//
1425 Expr *MSPropertyOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
1426 Expr *NewBase = capture(RefExpr->getBaseExpr());
1429 MSPropertyRefRebuilder(S, NewBase).rebuild(syntacticBase);
1431 return syntacticBase;
1434 ExprResult MSPropertyOpBuilder::buildGet() {
1435 if (!RefExpr->getPropertyDecl()->hasGetter()) {
1436 S.Diag(RefExpr->getMemberLoc(), diag::err_no_accessor_for_property)
1437 << 0 /* getter */ << RefExpr->getPropertyDecl();
1441 UnqualifiedId GetterName;
1442 IdentifierInfo *II = RefExpr->getPropertyDecl()->getGetterId();
1443 GetterName.setIdentifier(II, RefExpr->getMemberLoc());
1445 SS.Adopt(RefExpr->getQualifierLoc());
1446 ExprResult GetterExpr = S.ActOnMemberAccessExpr(
1447 S.getCurScope(), RefExpr->getBaseExpr(), SourceLocation(),
1448 RefExpr->isArrow() ? tok::arrow : tok::period, SS, SourceLocation(),
1449 GetterName, nullptr, true);
1450 if (GetterExpr.isInvalid()) {
1451 S.Diag(RefExpr->getMemberLoc(),
1452 diag::error_cannot_find_suitable_accessor) << 0 /* getter */
1453 << RefExpr->getPropertyDecl();
1457 MultiExprArg ArgExprs;
1458 return S.ActOnCallExpr(S.getCurScope(), GetterExpr.get(),
1459 RefExpr->getSourceRange().getBegin(), ArgExprs,
1460 RefExpr->getSourceRange().getEnd());
1463 ExprResult MSPropertyOpBuilder::buildSet(Expr *op, SourceLocation sl,
1464 bool captureSetValueAsResult) {
1465 if (!RefExpr->getPropertyDecl()->hasSetter()) {
1466 S.Diag(RefExpr->getMemberLoc(), diag::err_no_accessor_for_property)
1467 << 1 /* setter */ << RefExpr->getPropertyDecl();
1471 UnqualifiedId SetterName;
1472 IdentifierInfo *II = RefExpr->getPropertyDecl()->getSetterId();
1473 SetterName.setIdentifier(II, RefExpr->getMemberLoc());
1475 SS.Adopt(RefExpr->getQualifierLoc());
1476 ExprResult SetterExpr = S.ActOnMemberAccessExpr(
1477 S.getCurScope(), RefExpr->getBaseExpr(), SourceLocation(),
1478 RefExpr->isArrow() ? tok::arrow : tok::period, SS, SourceLocation(),
1479 SetterName, nullptr, true);
1480 if (SetterExpr.isInvalid()) {
1481 S.Diag(RefExpr->getMemberLoc(),
1482 diag::error_cannot_find_suitable_accessor) << 1 /* setter */
1483 << RefExpr->getPropertyDecl();
1487 SmallVector<Expr*, 1> ArgExprs;
1488 ArgExprs.push_back(op);
1489 return S.ActOnCallExpr(S.getCurScope(), SetterExpr.get(),
1490 RefExpr->getSourceRange().getBegin(), ArgExprs,
1491 op->getSourceRange().getEnd());
1494 //===----------------------------------------------------------------------===//
1495 // General Sema routines.
1496 //===----------------------------------------------------------------------===//
1498 ExprResult Sema::checkPseudoObjectRValue(Expr *E) {
1499 Expr *opaqueRef = E->IgnoreParens();
1500 if (ObjCPropertyRefExpr *refExpr
1501 = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1502 ObjCPropertyOpBuilder builder(*this, refExpr);
1503 return builder.buildRValueOperation(E);
1505 else if (ObjCSubscriptRefExpr *refExpr
1506 = dyn_cast<ObjCSubscriptRefExpr>(opaqueRef)) {
1507 ObjCSubscriptOpBuilder builder(*this, refExpr);
1508 return builder.buildRValueOperation(E);
1509 } else if (MSPropertyRefExpr *refExpr
1510 = dyn_cast<MSPropertyRefExpr>(opaqueRef)) {
1511 MSPropertyOpBuilder builder(*this, refExpr);
1512 return builder.buildRValueOperation(E);
1514 llvm_unreachable("unknown pseudo-object kind!");
1518 /// Check an increment or decrement of a pseudo-object expression.
1519 ExprResult Sema::checkPseudoObjectIncDec(Scope *Sc, SourceLocation opcLoc,
1520 UnaryOperatorKind opcode, Expr *op) {
1521 // Do nothing if the operand is dependent.
1522 if (op->isTypeDependent())
1523 return new (Context) UnaryOperator(op, opcode, Context.DependentTy,
1524 VK_RValue, OK_Ordinary, opcLoc);
1526 assert(UnaryOperator::isIncrementDecrementOp(opcode));
1527 Expr *opaqueRef = op->IgnoreParens();
1528 if (ObjCPropertyRefExpr *refExpr
1529 = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1530 ObjCPropertyOpBuilder builder(*this, refExpr);
1531 return builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1532 } else if (isa<ObjCSubscriptRefExpr>(opaqueRef)) {
1533 Diag(opcLoc, diag::err_illegal_container_subscripting_op);
1535 } else if (MSPropertyRefExpr *refExpr
1536 = dyn_cast<MSPropertyRefExpr>(opaqueRef)) {
1537 MSPropertyOpBuilder builder(*this, refExpr);
1538 return builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1540 llvm_unreachable("unknown pseudo-object kind!");
1544 ExprResult Sema::checkPseudoObjectAssignment(Scope *S, SourceLocation opcLoc,
1545 BinaryOperatorKind opcode,
1546 Expr *LHS, Expr *RHS) {
1547 // Do nothing if either argument is dependent.
1548 if (LHS->isTypeDependent() || RHS->isTypeDependent())
1549 return new (Context) BinaryOperator(LHS, RHS, opcode, Context.DependentTy,
1550 VK_RValue, OK_Ordinary, opcLoc, false);
1552 // Filter out non-overload placeholder types in the RHS.
1553 if (RHS->getType()->isNonOverloadPlaceholderType()) {
1554 ExprResult result = CheckPlaceholderExpr(RHS);
1555 if (result.isInvalid()) return ExprError();
1559 Expr *opaqueRef = LHS->IgnoreParens();
1560 if (ObjCPropertyRefExpr *refExpr
1561 = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1562 ObjCPropertyOpBuilder builder(*this, refExpr);
1563 return builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1564 } else if (ObjCSubscriptRefExpr *refExpr
1565 = dyn_cast<ObjCSubscriptRefExpr>(opaqueRef)) {
1566 ObjCSubscriptOpBuilder builder(*this, refExpr);
1567 return builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1568 } else if (MSPropertyRefExpr *refExpr
1569 = dyn_cast<MSPropertyRefExpr>(opaqueRef)) {
1570 MSPropertyOpBuilder builder(*this, refExpr);
1571 return builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1573 llvm_unreachable("unknown pseudo-object kind!");
1577 /// Given a pseudo-object reference, rebuild it without the opaque
1578 /// values. Basically, undo the behavior of rebuildAndCaptureObject.
1579 /// This should never operate in-place.
1580 static Expr *stripOpaqueValuesFromPseudoObjectRef(Sema &S, Expr *E) {
1581 Expr *opaqueRef = E->IgnoreParens();
1582 if (ObjCPropertyRefExpr *refExpr
1583 = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1584 // Class and super property references don't have opaque values in them.
1585 if (refExpr->isClassReceiver() || refExpr->isSuperReceiver())
1588 assert(refExpr->isObjectReceiver() && "Unknown receiver kind?");
1589 OpaqueValueExpr *baseOVE = cast<OpaqueValueExpr>(refExpr->getBase());
1590 return ObjCPropertyRefRebuilder(S, baseOVE->getSourceExpr()).rebuild(E);
1591 } else if (ObjCSubscriptRefExpr *refExpr
1592 = dyn_cast<ObjCSubscriptRefExpr>(opaqueRef)) {
1593 OpaqueValueExpr *baseOVE = cast<OpaqueValueExpr>(refExpr->getBaseExpr());
1594 OpaqueValueExpr *keyOVE = cast<OpaqueValueExpr>(refExpr->getKeyExpr());
1595 return ObjCSubscriptRefRebuilder(S, baseOVE->getSourceExpr(),
1596 keyOVE->getSourceExpr()).rebuild(E);
1597 } else if (MSPropertyRefExpr *refExpr
1598 = dyn_cast<MSPropertyRefExpr>(opaqueRef)) {
1599 OpaqueValueExpr *baseOVE = cast<OpaqueValueExpr>(refExpr->getBaseExpr());
1600 return MSPropertyRefRebuilder(S, baseOVE->getSourceExpr()).rebuild(E);
1602 llvm_unreachable("unknown pseudo-object kind!");
1606 /// Given a pseudo-object expression, recreate what it looks like
1607 /// syntactically without the attendant OpaqueValueExprs.
1609 /// This is a hack which should be removed when TreeTransform is
1610 /// capable of rebuilding a tree without stripping implicit
1612 Expr *Sema::recreateSyntacticForm(PseudoObjectExpr *E) {
1613 Expr *syntax = E->getSyntacticForm();
1614 if (UnaryOperator *uop = dyn_cast<UnaryOperator>(syntax)) {
1615 Expr *op = stripOpaqueValuesFromPseudoObjectRef(*this, uop->getSubExpr());
1616 return new (Context) UnaryOperator(op, uop->getOpcode(), uop->getType(),
1617 uop->getValueKind(), uop->getObjectKind(),
1618 uop->getOperatorLoc());
1619 } else if (CompoundAssignOperator *cop
1620 = dyn_cast<CompoundAssignOperator>(syntax)) {
1621 Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, cop->getLHS());
1622 Expr *rhs = cast<OpaqueValueExpr>(cop->getRHS())->getSourceExpr();
1623 return new (Context) CompoundAssignOperator(lhs, rhs, cop->getOpcode(),
1625 cop->getValueKind(),
1626 cop->getObjectKind(),
1627 cop->getComputationLHSType(),
1628 cop->getComputationResultType(),
1629 cop->getOperatorLoc(), false);
1630 } else if (BinaryOperator *bop = dyn_cast<BinaryOperator>(syntax)) {
1631 Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, bop->getLHS());
1632 Expr *rhs = cast<OpaqueValueExpr>(bop->getRHS())->getSourceExpr();
1633 return new (Context) BinaryOperator(lhs, rhs, bop->getOpcode(),
1634 bop->getType(), bop->getValueKind(),
1635 bop->getObjectKind(),
1636 bop->getOperatorLoc(), false);
1638 assert(syntax->hasPlaceholderType(BuiltinType::PseudoObject));
1639 return stripOpaqueValuesFromPseudoObjectRef(*this, syntax);