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/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"
41 
42 using namespace clang;
43 using namespace sema;
44 
45 namespace {
46   // Basically just a very focused copy of TreeTransform.
47   template <class T> struct Rebuilder {
48     Sema &S;
Rebuilder__anon83f8f2be0111::Rebuilder49     Rebuilder(Sema &S) : S(S) {}
50 
getDerived__anon83f8f2be0111::Rebuilder51     T &getDerived() { return static_cast<T&>(*this); }
52 
rebuild__anon83f8f2be0111::Rebuilder53     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);
58 
59       // Otherwise, we should look through and rebuild anything that
60       // IgnoreParens would.
61 
62       if (ParenExpr *parens = dyn_cast<ParenExpr>(e)) {
63         e = rebuild(parens->getSubExpr());
64         return new (S.Context) ParenExpr(parens->getLParen(),
65                                          parens->getRParen(),
66                                          e);
67       }
68 
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(),
73                                              uop->getType(),
74                                              uop->getValueKind(),
75                                              uop->getObjectKind(),
76                                              uop->getOperatorLoc());
77       }
78 
79       if (GenericSelectionExpr *gse = dyn_cast<GenericSelectionExpr>(e)) {
80         assert(!gse->isResultDependent());
81         unsigned resultIndex = gse->getResultIndex();
82         unsigned numAssocs = gse->getNumAssocs();
83 
84         SmallVector<Expr*, 8> assocs(numAssocs);
85         SmallVector<TypeSourceInfo*, 8> assocTypes(numAssocs);
86 
87         for (unsigned i = 0; i != numAssocs; ++i) {
88           Expr *assoc = gse->getAssocExpr(i);
89           if (i == resultIndex) assoc = rebuild(assoc);
90           assocs[i] = assoc;
91           assocTypes[i] = gse->getAssocTypeSourceInfo(i);
92         }
93 
94         return new (S.Context) GenericSelectionExpr(S.Context,
95                                                     gse->getGenericLoc(),
96                                                     gse->getControllingExpr(),
97                                                     assocTypes,
98                                                     assocs,
99                                                     gse->getDefaultLoc(),
100                                                     gse->getRParenLoc(),
101                                       gse->containsUnexpandedParameterPack(),
102                                                     resultIndex);
103       }
104 
105       if (ChooseExpr *ce = dyn_cast<ChooseExpr>(e)) {
106         assert(!ce->isConditionDependent());
107 
108         Expr *LHS = ce->getLHS(), *RHS = ce->getRHS();
109         Expr *&rebuiltExpr = ce->isConditionTrue() ? LHS : RHS;
110         rebuiltExpr = rebuild(rebuiltExpr);
111 
112         return new (S.Context) ChooseExpr(ce->getBuiltinLoc(),
113                                           ce->getCond(),
114                                           LHS, RHS,
115                                           rebuiltExpr->getType(),
116                                           rebuiltExpr->getValueKind(),
117                                           rebuiltExpr->getObjectKind(),
118                                           ce->getRParenLoc(),
119                                           ce->isConditionTrue(),
120                                           rebuiltExpr->isTypeDependent(),
121                                           rebuiltExpr->isValueDependent());
122       }
123 
124       llvm_unreachable("bad expression to rebuild!");
125     }
126   };
127 
128   struct ObjCPropertyRefRebuilder : Rebuilder<ObjCPropertyRefRebuilder> {
129     Expr *NewBase;
ObjCPropertyRefRebuilder__anon83f8f2be0111::ObjCPropertyRefRebuilder130     ObjCPropertyRefRebuilder(Sema &S, Expr *newBase)
131       : Rebuilder<ObjCPropertyRefRebuilder>(S), NewBase(newBase) {}
132 
133     typedef ObjCPropertyRefExpr specific_type;
rebuildSpecific__anon83f8f2be0111::ObjCPropertyRefRebuilder134     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());
138 
139       if (refExpr->isExplicitProperty()) {
140         return new (S.Context)
141           ObjCPropertyRefExpr(refExpr->getExplicitProperty(),
142                               refExpr->getType(), refExpr->getValueKind(),
143                               refExpr->getObjectKind(), refExpr->getLocation(),
144                               NewBase);
145       }
146       return new (S.Context)
147         ObjCPropertyRefExpr(refExpr->getImplicitPropertyGetter(),
148                             refExpr->getImplicitPropertySetter(),
149                             refExpr->getType(), refExpr->getValueKind(),
150                             refExpr->getObjectKind(),refExpr->getLocation(),
151                             NewBase);
152     }
153   };
154 
155   struct ObjCSubscriptRefRebuilder : Rebuilder<ObjCSubscriptRefRebuilder> {
156     Expr *NewBase;
157     Expr *NewKeyExpr;
ObjCSubscriptRefRebuilder__anon83f8f2be0111::ObjCSubscriptRefRebuilder158     ObjCSubscriptRefRebuilder(Sema &S, Expr *newBase, Expr *newKeyExpr)
159     : Rebuilder<ObjCSubscriptRefRebuilder>(S),
160       NewBase(newBase), NewKeyExpr(newKeyExpr) {}
161 
162     typedef ObjCSubscriptRefExpr specific_type;
rebuildSpecific__anon83f8f2be0111::ObjCSubscriptRefRebuilder163     Expr *rebuildSpecific(ObjCSubscriptRefExpr *refExpr) {
164       assert(refExpr->getBaseExpr());
165       assert(refExpr->getKeyExpr());
166 
167       return new (S.Context)
168         ObjCSubscriptRefExpr(NewBase,
169                              NewKeyExpr,
170                              refExpr->getType(), refExpr->getValueKind(),
171                              refExpr->getObjectKind(),refExpr->getAtIndexMethodDecl(),
172                              refExpr->setAtIndexMethodDecl(),
173                              refExpr->getRBracket());
174     }
175   };
176 
177   struct MSPropertyRefRebuilder : Rebuilder<MSPropertyRefRebuilder> {
178     Expr *NewBase;
MSPropertyRefRebuilder__anon83f8f2be0111::MSPropertyRefRebuilder179     MSPropertyRefRebuilder(Sema &S, Expr *newBase)
180     : Rebuilder<MSPropertyRefRebuilder>(S), NewBase(newBase) {}
181 
182     typedef MSPropertyRefExpr specific_type;
rebuildSpecific__anon83f8f2be0111::MSPropertyRefRebuilder183     Expr *rebuildSpecific(MSPropertyRefExpr *refExpr) {
184       assert(refExpr->getBaseExpr());
185 
186       return new (S.Context)
187         MSPropertyRefExpr(NewBase, refExpr->getPropertyDecl(),
188                        refExpr->isArrow(), refExpr->getType(),
189                        refExpr->getValueKind(), refExpr->getQualifierLoc(),
190                        refExpr->getMemberLoc());
191     }
192   };
193 
194   class PseudoOpBuilder {
195   public:
196     Sema &S;
197     unsigned ResultIndex;
198     SourceLocation GenericLoc;
199     SmallVector<Expr *, 4> Semantics;
200 
PseudoOpBuilder(Sema & S,SourceLocation genericLoc)201     PseudoOpBuilder(Sema &S, SourceLocation genericLoc)
202       : S(S), ResultIndex(PseudoObjectExpr::NoResult),
203         GenericLoc(genericLoc) {}
204 
~PseudoOpBuilder()205     virtual ~PseudoOpBuilder() {}
206 
207     /// Add a normal semantic expression.
addSemanticExpr(Expr * semantic)208     void addSemanticExpr(Expr *semantic) {
209       Semantics.push_back(semantic);
210     }
211 
212     /// Add the 'result' semantic expression.
addResultSemanticExpr(Expr * resultExpr)213     void addResultSemanticExpr(Expr *resultExpr) {
214       assert(ResultIndex == PseudoObjectExpr::NoResult);
215       ResultIndex = Semantics.size();
216       Semantics.push_back(resultExpr);
217     }
218 
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,
226                                     Expr *op);
227 
228     virtual ExprResult complete(Expr *syntacticForm);
229 
230     OpaqueValueExpr *capture(Expr *op);
231     OpaqueValueExpr *captureValueAsResult(Expr *op);
232 
setResultToLastSemantic()233     void setResultToLastSemantic() {
234       assert(ResultIndex == PseudoObjectExpr::NoResult);
235       ResultIndex = Semantics.size() - 1;
236     }
237 
238     /// Return true if assignments have a non-void result.
CanCaptureValue(Expr * exp)239     bool CanCaptureValue(Expr *exp) {
240       if (exp->isGLValue())
241         return true;
242       QualType ty = exp->getType();
243       assert(!ty->isIncompleteType());
244       assert(!ty->isDependentType());
245 
246       if (const CXXRecordDecl *ClassDecl = ty->getAsCXXRecordDecl())
247         return ClassDecl->isTriviallyCopyable();
248       return true;
249     }
250 
251     virtual Expr *rebuildAndCaptureObject(Expr *) = 0;
252     virtual ExprResult buildGet() = 0;
253     virtual ExprResult buildSet(Expr *, SourceLocation,
254                                 bool captureSetValueAsResult) = 0;
255   };
256 
257   /// A PseudoOpBuilder for Objective-C \@properties.
258   class ObjCPropertyOpBuilder : public PseudoOpBuilder {
259     ObjCPropertyRefExpr *RefExpr;
260     ObjCPropertyRefExpr *SyntacticRefExpr;
261     OpaqueValueExpr *InstanceReceiver;
262     ObjCMethodDecl *Getter;
263 
264     ObjCMethodDecl *Setter;
265     Selector SetterSelector;
266     Selector GetterSelector;
267 
268   public:
ObjCPropertyOpBuilder(Sema & S,ObjCPropertyRefExpr * refExpr)269     ObjCPropertyOpBuilder(Sema &S, ObjCPropertyRefExpr *refExpr) :
270       PseudoOpBuilder(S, refExpr->getLocation()), RefExpr(refExpr),
271       SyntacticRefExpr(nullptr), InstanceReceiver(nullptr), Getter(nullptr),
272       Setter(nullptr) {
273     }
274 
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,
282                                     Expr *op);
283 
284     bool tryBuildGetOfReference(Expr *op, ExprResult &result);
285     bool findSetter(bool warn=true);
286     bool findGetter();
287     void DiagnoseUnsupportedPropertyUse();
288 
289     Expr *rebuildAndCaptureObject(Expr *syntacticBase) override;
290     ExprResult buildGet() override;
291     ExprResult buildSet(Expr *op, SourceLocation, bool) override;
292     ExprResult complete(Expr *SyntacticForm) override;
293 
294     bool isWeakProperty() const;
295   };
296 
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;
304 
305    ObjCMethodDecl *AtIndexSetter;
306    Selector AtIndexSetterSelector;
307 
308  public:
ObjCSubscriptOpBuilder(Sema & S,ObjCSubscriptRefExpr * refExpr)309     ObjCSubscriptOpBuilder(Sema &S, ObjCSubscriptRefExpr *refExpr) :
310       PseudoOpBuilder(S, refExpr->getSourceRange().getBegin()),
311       RefExpr(refExpr),
312       InstanceBase(nullptr), InstanceKey(nullptr),
313       AtIndexGetter(nullptr), AtIndexSetter(nullptr) {}
314 
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;
321 
322    bool findAtIndexGetter();
323    bool findAtIndexSetter();
324 
325    ExprResult buildGet() override;
326    ExprResult buildSet(Expr *op, SourceLocation, bool) override;
327  };
328 
329  class MSPropertyOpBuilder : public PseudoOpBuilder {
330    MSPropertyRefExpr *RefExpr;
331 
332  public:
MSPropertyOpBuilder(Sema & S,MSPropertyRefExpr * refExpr)333    MSPropertyOpBuilder(Sema &S, MSPropertyRefExpr *refExpr) :
334      PseudoOpBuilder(S, refExpr->getSourceRange().getBegin()),
335      RefExpr(refExpr) {}
336 
337    Expr *rebuildAndCaptureObject(Expr *) override;
338    ExprResult buildGet() override;
339    ExprResult buildSet(Expr *op, SourceLocation, bool) override;
340  };
341 }
342 
343 /// Capture the given expression in an OpaqueValueExpr.
capture(Expr * e)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(),
349                                     e);
350 
351   // Make sure we bind that in the semantics.
352   addSemanticExpr(captured);
353   return captured;
354 }
355 
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.
359 ///
360 /// \returns the captured expression, which will be the
361 ///   same as the input if the input was already captured
captureValueAsResult(Expr * e)362 OpaqueValueExpr *PseudoOpBuilder::captureValueAsResult(Expr *e) {
363   assert(ResultIndex == PseudoObjectExpr::NoResult);
364 
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();
370     return cap;
371   }
372 
373   // Otherwise, it must already be one of our semantic expressions;
374   // set ResultIndex to its index.
375   unsigned index = 0;
376   for (;; ++index) {
377     assert(index < Semantics.size() &&
378            "captured expression not found in semantics!");
379     if (e == Semantics[index]) break;
380   }
381   ResultIndex = index;
382   return cast<OpaqueValueExpr>(e);
383 }
384 
385 /// The routine which creates the final PseudoObjectExpr.
complete(Expr * syntactic)386 ExprResult PseudoOpBuilder::complete(Expr *syntactic) {
387   return PseudoObjectExpr::Create(S.Context, syntactic,
388                                   Semantics, ResultIndex);
389 }
390 
391 /// The main skeleton for building an r-value operation.
buildRValueOperation(Expr * op)392 ExprResult PseudoOpBuilder::buildRValueOperation(Expr *op) {
393   Expr *syntacticBase = rebuildAndCaptureObject(op);
394 
395   ExprResult getExpr = buildGet();
396   if (getExpr.isInvalid()) return ExprError();
397   addResultSemanticExpr(getExpr.get());
398 
399   return complete(syntacticBase);
400 }
401 
402 /// The basic skeleton for building a simple or compound
403 /// assignment operation.
404 ExprResult
buildAssignmentOperation(Scope * Sc,SourceLocation opcLoc,BinaryOperatorKind opcode,Expr * LHS,Expr * RHS)405 PseudoOpBuilder::buildAssignmentOperation(Scope *Sc, SourceLocation opcLoc,
406                                           BinaryOperatorKind opcode,
407                                           Expr *LHS, Expr *RHS) {
408   assert(BinaryOperator::isAssignmentOp(opcode));
409 
410   // Recover from user error
411   if (isa<UnresolvedLookupExpr>(RHS))
412     return ExprError();
413 
414   Expr *syntacticLHS = rebuildAndCaptureObject(LHS);
415   OpaqueValueExpr *capturedRHS = capture(RHS);
416 
417   Expr *syntactic;
418 
419   ExprResult result;
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);
426   } else {
427     ExprResult opLHS = buildGet();
428     if (opLHS.isInvalid()) return ExprError();
429 
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();
436 
437     syntactic =
438       new (S.Context) CompoundAssignOperator(syntacticLHS, capturedRHS, opcode,
439                                              result.get()->getType(),
440                                              result.get()->getValueKind(),
441                                              OK_Ordinary,
442                                              opLHS.get()->getType(),
443                                              result.get()->getType(),
444                                              opcLoc, false);
445   }
446 
447   // The result of the assignment, if not void, is the value set into
448   // the l-value.
449   result = buildSet(result.get(), opcLoc, /*captureSetValueAsResult*/ true);
450   if (result.isInvalid()) return ExprError();
451   addSemanticExpr(result.get());
452 
453   return complete(syntactic);
454 }
455 
456 /// The basic skeleton for building an increment or decrement
457 /// operation.
458 ExprResult
buildIncDecOperation(Scope * Sc,SourceLocation opcLoc,UnaryOperatorKind opcode,Expr * op)459 PseudoOpBuilder::buildIncDecOperation(Scope *Sc, SourceLocation opcLoc,
460                                       UnaryOperatorKind opcode,
461                                       Expr *op) {
462   assert(UnaryOperator::isIncrementDecrementOp(opcode));
463 
464   Expr *syntacticOp = rebuildAndCaptureObject(op);
465 
466   // Load the value.
467   ExprResult result = buildGet();
468   if (result.isInvalid()) return ExprError();
469 
470   QualType resultType = result.get()->getType();
471 
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();
477   }
478 
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,
482                                      GenericLoc);
483 
484   if (UnaryOperator::isIncrementOp(opcode)) {
485     result = S.BuildBinOp(Sc, opcLoc, BO_Add, result.get(), one);
486   } else {
487     result = S.BuildBinOp(Sc, opcLoc, BO_Sub, result.get(), one);
488   }
489   if (result.isInvalid()) return ExprError();
490 
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());
496 
497   UnaryOperator *syntactic =
498     new (S.Context) UnaryOperator(syntacticOp, opcode, resultType,
499                                   VK_LValue, OK_Ordinary, opcLoc);
500   return complete(syntactic);
501 }
502 
503 
504 //===----------------------------------------------------------------------===//
505 //  Objective-C @property and implicit property references
506 //===----------------------------------------------------------------------===//
507 
508 /// Look up a method in the receiver type of an Objective-C property
509 /// reference.
LookupMethodInReceiverType(Sema & S,Selector sel,const ObjCPropertyRefExpr * PRE)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>();
515 
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
520       // methods.
521       ObjCMethodDecl *method =
522         cast<ObjCMethodDecl>(S.CurContext->getNonClosureAncestor());
523       return S.LookupMethodInObjectType(sel,
524                  S.Context.getObjCInterfaceType(method->getClassInterface()),
525                                         /*instance*/ false);
526     }
527 
528     return S.LookupMethodInObjectType(sel, PT->getPointeeType(), true);
529   }
530 
531   if (PRE->isSuperReceiver()) {
532     if (const ObjCObjectPointerType *PT =
533         PRE->getSuperReceiverType()->getAs<ObjCObjectPointerType>())
534       return S.LookupMethodInObjectType(sel, PT->getPointeeType(), true);
535 
536     return S.LookupMethodInObjectType(sel, PRE->getSuperReceiverType(), false);
537   }
538 
539   assert(PRE->isClassReceiver() && "Invalid expression");
540   QualType IT = S.Context.getObjCInterfaceType(PRE->getClassReceiver());
541   return S.LookupMethodInObjectType(sel, IT, false);
542 }
543 
isWeakProperty() const544 bool ObjCPropertyOpBuilder::isWeakProperty() const {
545   QualType T;
546   if (RefExpr->isExplicitProperty()) {
547     const ObjCPropertyDecl *Prop = RefExpr->getExplicitProperty();
548     if (Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak)
549       return !Prop->hasAttr<IBOutletAttr>();
550 
551     T = Prop->getType();
552   } else if (Getter) {
553     T = Getter->getReturnType();
554   } else {
555     return false;
556   }
557 
558   return T.getObjCLifetime() == Qualifiers::OCL_Weak;
559 }
560 
findGetter()561 bool ObjCPropertyOpBuilder::findGetter() {
562   if (Getter) return true;
563 
564   // For implicit properties, just trust the lookup we already did.
565   if (RefExpr->isImplicitProperty()) {
566     if ((Getter = RefExpr->getImplicitPropertyGetter())) {
567       GetterSelector = Getter->getSelector();
568       return true;
569     }
570     else {
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));
578       GetterSelector =
579         S.PP.getSelectorTable().getNullarySelector(getterName);
580       return false;
581     }
582   }
583 
584   ObjCPropertyDecl *prop = RefExpr->getExplicitProperty();
585   Getter = LookupMethodInReceiverType(S, prop->getGetterName(), RefExpr);
586   return (Getter != nullptr);
587 }
588 
589 /// Try to find the most accurate setter declaration for the property
590 /// reference.
591 ///
592 /// \return true if a setter was found, in which case Setter
findSetter(bool warn)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()) {
597       Setter = setter;
598       SetterSelector = setter->getSelector();
599       return true;
600     } else {
601       IdentifierInfo *getterName =
602         RefExpr->getImplicitPropertyGetter()->getSelector()
603           .getIdentifierInfoForSlot(0);
604       SetterSelector =
605         SelectorTable::constructSetterSelector(S.PP.getIdentifierTable(),
606                                                S.PP.getSelectorTable(),
607                                                getterName);
608       return false;
609     }
610   }
611 
612   // For explicit properties, this is more involved.
613   ObjCPropertyDecl *prop = RefExpr->getExplicitProperty();
614   SetterSelector = prop->getSetterName();
615 
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);
635           }
636       }
637     Setter = setter;
638     return true;
639   }
640 
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.
645 
646   return false;
647 }
648 
DiagnoseUnsupportedPropertyUse()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);
657     }
658   }
659 }
660 
661 /// Capture the base object of an Objective-C property expression.
rebuildAndCaptureObject(Expr * syntacticBase)662 Expr *ObjCPropertyOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
663   assert(InstanceReceiver == nullptr);
664 
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());
669 
670     syntacticBase =
671       ObjCPropertyRefRebuilder(S, InstanceReceiver).rebuild(syntacticBase);
672   }
673 
674   if (ObjCPropertyRefExpr *
675         refE = dyn_cast<ObjCPropertyRefExpr>(syntacticBase->IgnoreParens()))
676     SyntacticRefExpr = refE;
677 
678   return syntacticBase;
679 }
680 
681 /// Load from an Objective-C property reference.
buildGet()682 ExprResult ObjCPropertyOpBuilder::buildGet() {
683   findGetter();
684   if (!Getter) {
685     DiagnoseUnsupportedPropertyUse();
686     return ExprError();
687   }
688 
689   if (SyntacticRefExpr)
690     SyntacticRefExpr->setIsMessagingGetter();
691 
692   QualType receiverType;
693   if (RefExpr->isClassReceiver()) {
694     receiverType = S.Context.getObjCInterfaceType(RefExpr->getClassReceiver());
695   } else if (RefExpr->isSuperReceiver()) {
696     receiverType = RefExpr->getSuperReceiverType();
697   } else {
698     assert(InstanceReceiver);
699     receiverType = InstanceReceiver->getType();
700   }
701   if (!Getter->isImplicit())
702     S.DiagnoseUseOfDecl(Getter, GenericLoc, nullptr, true);
703   // Build a message-send.
704   ExprResult msg;
705   if ((Getter->isInstanceMethod() && !RefExpr->isClassReceiver()) ||
706       RefExpr->isObjectReceiver()) {
707     assert(InstanceReceiver || RefExpr->isSuperReceiver());
708     msg = S.BuildInstanceMessageImplicit(InstanceReceiver, receiverType,
709                                          GenericLoc, Getter->getSelector(),
710                                          Getter, None);
711   } else {
712     msg = S.BuildClassMessageImplicit(receiverType, RefExpr->isSuperReceiver(),
713                                       GenericLoc, Getter->getSelector(),
714                                       Getter, None);
715   }
716   return msg;
717 }
718 
719 /// Store to an Objective-C property reference.
720 ///
721 /// \param captureSetValueAsResult If true, capture the actual
722 ///   value being set as the value of the property operation.
buildSet(Expr * op,SourceLocation opcLoc,bool captureSetValueAsResult)723 ExprResult ObjCPropertyOpBuilder::buildSet(Expr *op, SourceLocation opcLoc,
724                                            bool captureSetValueAsResult) {
725   if (!findSetter(false)) {
726     DiagnoseUnsupportedPropertyUse();
727     return ExprError();
728   }
729 
730   if (SyntacticRefExpr)
731     SyntacticRefExpr->setIsMessagingSetter();
732 
733   QualType receiverType;
734   if (RefExpr->isClassReceiver()) {
735     receiverType = S.Context.getObjCInterfaceType(RefExpr->getClassReceiver());
736   } else if (RefExpr->isSuperReceiver()) {
737     receiverType = RefExpr->getSuperReceiverType();
738   } else {
739     assert(InstanceReceiver);
740     receiverType = InstanceReceiver->getType();
741   }
742 
743   // Use assignment constraints when possible; they give us better
744   // diagnostics.  "When possible" basically means anything except a
745   // C++ class type.
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(),
754                                      Sema::AA_Assigning))
755         return ExprError();
756 
757       op = opResult.get();
758       assert(op && "successful assignment left argument invalid?");
759     }
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()) {
767         op = Initializer;
768       }
769     }
770   }
771 
772   // Arguments.
773   Expr *args[] = { op };
774 
775   // Build a message-send.
776   ExprResult msg;
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));
784   } else {
785     msg = S.BuildClassMessageImplicit(receiverType, RefExpr->isSuperReceiver(),
786                                       GenericLoc,
787                                       SetterSelector, Setter,
788                                       MultiExprArg(args, 1));
789   }
790 
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));
797   }
798 
799   return msg;
800 }
801 
802 /// @property-specific behavior for doing lvalue-to-rvalue conversion.
buildRValueOperation(Expr * op)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();
809     return ExprError();
810   }
811 
812   ExprResult result = PseudoOpBuilder::buildRValueOperation(op);
813   if (result.isInvalid()) return ExprError();
814 
815   if (RefExpr->isExplicitProperty() && !Getter->hasRelatedResultType())
816     S.DiagnosePropertyAccessorMismatch(RefExpr->getExplicitProperty(),
817                                        Getter, RefExpr->getLocation());
818 
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);
828       }
829     }
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);
835     }
836   }
837 
838   return result;
839 }
840 
841 /// Try to build this as a call to a getter that returns a reference.
842 ///
843 /// \return true if it was possible, whether or not it actually
844 ///   succeeded
tryBuildGetOfReference(Expr * op,ExprResult & result)845 bool ObjCPropertyOpBuilder::tryBuildGetOfReference(Expr *op,
846                                                    ExprResult &result) {
847   if (!S.getLangOpts().CPlusPlus) return false;
848 
849   findGetter();
850   if (!Getter) {
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();
854     return true;
855   }
856 
857   // Only do this if the getter returns an l-value reference type.
858   QualType resultType = Getter->getReturnType();
859   if (!resultType->isLValueReferenceType()) return false;
860 
861   result = buildRValueOperation(op);
862   return true;
863 }
864 
865 /// @property-specific behavior for doing assignments.
866 ExprResult
buildAssignmentOperation(Scope * Sc,SourceLocation opcLoc,BinaryOperatorKind opcode,Expr * LHS,Expr * RHS)867 ObjCPropertyOpBuilder::buildAssignmentOperation(Scope *Sc,
868                                                 SourceLocation opcLoc,
869                                                 BinaryOperatorKind opcode,
870                                                 Expr *LHS, Expr *RHS) {
871   assert(BinaryOperator::isAssignmentOp(opcode));
872 
873   // If there's no setter, we have no choice but to try to assign to
874   // the result of the getter.
875   if (!findSetter()) {
876     ExprResult result;
877     if (tryBuildGetOfReference(LHS, result)) {
878       if (result.isInvalid()) return ExprError();
879       return S.BuildBinOp(Sc, opcLoc, opcode, result.get(), RHS);
880     }
881 
882     // Otherwise, it's an error.
883     S.Diag(opcLoc, diag::err_nosetter_property_assignment)
884       << unsigned(RefExpr->isImplicitProperty())
885       << SetterSelector
886       << LHS->getSourceRange() << RHS->getSourceRange();
887     return ExprError();
888   }
889 
890   // If there is a setter, we definitely want to use it.
891 
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();
896     return ExprError();
897   }
898 
899   ExprResult result =
900     PseudoOpBuilder::buildAssignmentOperation(Sc, opcLoc, opcode, LHS, RHS);
901   if (result.isInvalid()) return ExprError();
902 
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);
907   }
908 
909   return result;
910 }
911 
912 /// @property-specific behavior for doing increments and decrements.
913 ExprResult
buildIncDecOperation(Scope * Sc,SourceLocation opcLoc,UnaryOperatorKind opcode,Expr * op)914 ObjCPropertyOpBuilder::buildIncDecOperation(Scope *Sc, SourceLocation opcLoc,
915                                             UnaryOperatorKind opcode,
916                                             Expr *op) {
917   // If there's no setter, we have no choice but to try to assign to
918   // the result of the getter.
919   if (!findSetter()) {
920     ExprResult result;
921     if (tryBuildGetOfReference(op, result)) {
922       if (result.isInvalid()) return ExprError();
923       return S.BuildUnaryOp(Sc, opcLoc, opcode, result.get());
924     }
925 
926     // Otherwise, it's an error.
927     S.Diag(opcLoc, diag::err_nosetter_property_incdec)
928       << unsigned(RefExpr->isImplicitProperty())
929       << unsigned(UnaryOperator::isDecrementOp(opcode))
930       << SetterSelector
931       << op->getSourceRange();
932     return ExprError();
933   }
934 
935   // If there is a setter, we definitely want to use it.
936 
937   // We also need a getter.
938   if (!findGetter()) {
939     assert(RefExpr->isImplicitProperty());
940     S.Diag(opcLoc, diag::err_nogetter_property_incdec)
941       << unsigned(UnaryOperator::isDecrementOp(opcode))
942       << GetterSelector
943       << op->getSourceRange();
944     return ExprError();
945   }
946 
947   return PseudoOpBuilder::buildIncDecOperation(Sc, opcLoc, opcode, op);
948 }
949 
complete(Expr * SyntacticForm)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());
956 
957   return PseudoOpBuilder::complete(SyntacticForm);
958 }
959 
960 // ObjCSubscript build stuff.
961 //
962 
963 /// objective-c subscripting-specific behavior for doing lvalue-to-rvalue
964 /// conversion.
965 /// FIXME. Remove this routine if it is proven that no additional
966 /// specifity is needed.
buildRValueOperation(Expr * op)967 ExprResult ObjCSubscriptOpBuilder::buildRValueOperation(Expr *op) {
968   ExprResult result = PseudoOpBuilder::buildRValueOperation(op);
969   if (result.isInvalid()) return ExprError();
970   return result;
971 }
972 
973 /// objective-c subscripting-specific  behavior for doing assignments.
974 ExprResult
buildAssignmentOperation(Scope * Sc,SourceLocation opcLoc,BinaryOperatorKind opcode,Expr * LHS,Expr * RHS)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())
982     return ExprError();
983 
984   // Verify that we can do a compound assignment.
985   if (opcode != BO_Assign && !findAtIndexGetter())
986     return ExprError();
987 
988   ExprResult result =
989   PseudoOpBuilder::buildAssignmentOperation(Sc, opcLoc, opcode, LHS, RHS);
990   if (result.isInvalid()) return ExprError();
991 
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);
996   }
997 
998   return result;
999 }
1000 
1001 /// Capture the base object of an Objective-C Index'ed expression.
rebuildAndCaptureObject(Expr * syntacticBase)1002 Expr *ObjCSubscriptOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
1003   assert(InstanceBase == nullptr);
1004 
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());
1009 
1010   syntacticBase =
1011     ObjCSubscriptRefRebuilder(S, InstanceBase,
1012                               InstanceKey).rebuild(syntacticBase);
1013 
1014   return syntacticBase;
1015 }
1016 
1017 /// CheckSubscriptingKind - This routine decide what type
1018 /// of indexing represented by "FromE" is being done.
1019 Sema::ObjCSubscriptKind
CheckSubscriptingKind(Expr * FromE)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())
1024     return OS_Array;
1025 
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>();
1029   if (!RecordTy &&
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(), "@");
1041     else
1042       Diag(FromE->getExprLoc(), diag::err_objc_subscript_type_conversion)
1043         << T;
1044     return OS_Error;
1045   }
1046 
1047   // We must have a complete class type.
1048   if (RequireCompleteType(FromE->getExprLoc(), T,
1049                           diag::err_objc_index_incomplete_class_type, FromE))
1050     return OS_Error;
1051 
1052   // Look for a conversion to an integral, enumeration type, or
1053   // objective-C pointer type.
1054   int NoIntegrals=0, NoObjCIdPointers=0;
1055   SmallVector<CXXConversionDecl *, 4> ConversionDecls;
1056 
1057   for (NamedDecl *D : cast<CXXRecordDecl>(RecordTy->getDecl())
1058                           ->getVisibleConversionFunctions()) {
1059     if (CXXConversionDecl *Conversion =
1060             dyn_cast<CXXConversionDecl>(D->getUnderlyingDecl())) {
1061       QualType CT = Conversion->getConversionType().getNonReferenceType();
1062       if (CT->isIntegralOrEnumerationType()) {
1063         ++NoIntegrals;
1064         ConversionDecls.push_back(Conversion);
1065       }
1066       else if (CT->isObjCIdType() ||CT->isBlockPointerType()) {
1067         ++NoObjCIdPointers;
1068         ConversionDecls.push_back(Conversion);
1069       }
1070     }
1071   }
1072   if (NoIntegrals ==1 && NoObjCIdPointers == 0)
1073     return OS_Array;
1074   if (NoIntegrals == 0 && NoObjCIdPointers == 1)
1075     return OS_Dictionary;
1076   if (NoIntegrals == 0 && NoObjCIdPointers == 0) {
1077     // No conversion function was found. Issue diagnostic and return.
1078     Diag(FromE->getExprLoc(), diag::err_objc_subscript_type_conversion)
1079       << FromE->getType();
1080     return OS_Error;
1081   }
1082   Diag(FromE->getExprLoc(), diag::err_objc_multiple_subscript_type_conversion)
1083       << FromE->getType();
1084   for (unsigned int i = 0; i < ConversionDecls.size(); i++)
1085     Diag(ConversionDecls[i]->getLocation(), diag::not_conv_function_declared_at);
1086 
1087   return OS_Error;
1088 }
1089 
1090 /// CheckKeyForObjCARCConversion - This routine suggests bridge casting of CF
1091 /// objects used as dictionary subscript key objects.
CheckKeyForObjCARCConversion(Sema & S,QualType ContainerT,Expr * Key)1092 static void CheckKeyForObjCARCConversion(Sema &S, QualType ContainerT,
1093                                          Expr *Key) {
1094   if (ContainerT.isNull())
1095     return;
1096   // dictionary subscripting.
1097   // - (id)objectForKeyedSubscript:(id)key;
1098   IdentifierInfo *KeyIdents[] = {
1099     &S.Context.Idents.get("objectForKeyedSubscript")
1100   };
1101   Selector GetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
1102   ObjCMethodDecl *Getter = S.LookupMethodInObjectType(GetterSelector, ContainerT,
1103                                                       true /*instance*/);
1104   if (!Getter)
1105     return;
1106   QualType T = Getter->parameters()[0]->getType();
1107   S.CheckObjCARCConversion(Key->getSourceRange(),
1108                          T, Key, Sema::CCK_ImplicitConversion);
1109 }
1110 
findAtIndexGetter()1111 bool ObjCSubscriptOpBuilder::findAtIndexGetter() {
1112   if (AtIndexGetter)
1113     return true;
1114 
1115   Expr *BaseExpr = RefExpr->getBaseExpr();
1116   QualType BaseT = BaseExpr->getType();
1117 
1118   QualType ResultType;
1119   if (const ObjCObjectPointerType *PTy =
1120       BaseT->getAs<ObjCObjectPointerType>()) {
1121     ResultType = PTy->getPointeeType();
1122     if (const ObjCObjectType *iQFaceTy =
1123         ResultType->getAsObjCQualifiedInterfaceType())
1124       ResultType = iQFaceTy->getBaseType();
1125   }
1126   Sema::ObjCSubscriptKind Res =
1127     S.CheckSubscriptingKind(RefExpr->getKeyExpr());
1128   if (Res == Sema::OS_Error) {
1129     if (S.getLangOpts().ObjCAutoRefCount)
1130       CheckKeyForObjCARCConversion(S, ResultType,
1131                                    RefExpr->getKeyExpr());
1132     return false;
1133   }
1134   bool arrayRef = (Res == Sema::OS_Array);
1135 
1136   if (ResultType.isNull()) {
1137     S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_base_type)
1138       << BaseExpr->getType() << arrayRef;
1139     return false;
1140   }
1141   if (!arrayRef) {
1142     // dictionary subscripting.
1143     // - (id)objectForKeyedSubscript:(id)key;
1144     IdentifierInfo *KeyIdents[] = {
1145       &S.Context.Idents.get("objectForKeyedSubscript")
1146     };
1147     AtIndexGetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
1148   }
1149   else {
1150     // - (id)objectAtIndexedSubscript:(size_t)index;
1151     IdentifierInfo *KeyIdents[] = {
1152       &S.Context.Idents.get("objectAtIndexedSubscript")
1153     };
1154 
1155     AtIndexGetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
1156   }
1157 
1158   AtIndexGetter = S.LookupMethodInObjectType(AtIndexGetterSelector, ResultType,
1159                                              true /*instance*/);
1160   bool receiverIdType = (BaseT->isObjCIdType() ||
1161                          BaseT->isObjCQualifiedIdType());
1162 
1163   if (!AtIndexGetter && S.getLangOpts().DebuggerObjCLiteral) {
1164     AtIndexGetter = ObjCMethodDecl::Create(S.Context, SourceLocation(),
1165                            SourceLocation(), AtIndexGetterSelector,
1166                            S.Context.getObjCIdType() /*ReturnType*/,
1167                            nullptr /*TypeSourceInfo */,
1168                            S.Context.getTranslationUnitDecl(),
1169                            true /*Instance*/, false/*isVariadic*/,
1170                            /*isPropertyAccessor=*/false,
1171                            /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
1172                            ObjCMethodDecl::Required,
1173                            false);
1174     ParmVarDecl *Argument = ParmVarDecl::Create(S.Context, AtIndexGetter,
1175                                                 SourceLocation(), SourceLocation(),
1176                                                 arrayRef ? &S.Context.Idents.get("index")
1177                                                          : &S.Context.Idents.get("key"),
1178                                                 arrayRef ? S.Context.UnsignedLongTy
1179                                                          : S.Context.getObjCIdType(),
1180                                                 /*TInfo=*/nullptr,
1181                                                 SC_None,
1182                                                 nullptr);
1183     AtIndexGetter->setMethodParams(S.Context, Argument, None);
1184   }
1185 
1186   if (!AtIndexGetter) {
1187     if (!receiverIdType) {
1188       S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_method_not_found)
1189       << BaseExpr->getType() << 0 << arrayRef;
1190       return false;
1191     }
1192     AtIndexGetter =
1193       S.LookupInstanceMethodInGlobalPool(AtIndexGetterSelector,
1194                                          RefExpr->getSourceRange(),
1195                                          true);
1196   }
1197 
1198   if (AtIndexGetter) {
1199     QualType T = AtIndexGetter->parameters()[0]->getType();
1200     if ((arrayRef && !T->isIntegralOrEnumerationType()) ||
1201         (!arrayRef && !T->isObjCObjectPointerType())) {
1202       S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1203              arrayRef ? diag::err_objc_subscript_index_type
1204                       : diag::err_objc_subscript_key_type) << T;
1205       S.Diag(AtIndexGetter->parameters()[0]->getLocation(),
1206              diag::note_parameter_type) << T;
1207       return false;
1208     }
1209     QualType R = AtIndexGetter->getReturnType();
1210     if (!R->isObjCObjectPointerType()) {
1211       S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1212              diag::err_objc_indexing_method_result_type) << R << arrayRef;
1213       S.Diag(AtIndexGetter->getLocation(), diag::note_method_declared_at) <<
1214         AtIndexGetter->getDeclName();
1215     }
1216   }
1217   return true;
1218 }
1219 
findAtIndexSetter()1220 bool ObjCSubscriptOpBuilder::findAtIndexSetter() {
1221   if (AtIndexSetter)
1222     return true;
1223 
1224   Expr *BaseExpr = RefExpr->getBaseExpr();
1225   QualType BaseT = BaseExpr->getType();
1226 
1227   QualType ResultType;
1228   if (const ObjCObjectPointerType *PTy =
1229       BaseT->getAs<ObjCObjectPointerType>()) {
1230     ResultType = PTy->getPointeeType();
1231     if (const ObjCObjectType *iQFaceTy =
1232         ResultType->getAsObjCQualifiedInterfaceType())
1233       ResultType = iQFaceTy->getBaseType();
1234   }
1235 
1236   Sema::ObjCSubscriptKind Res =
1237     S.CheckSubscriptingKind(RefExpr->getKeyExpr());
1238   if (Res == Sema::OS_Error) {
1239     if (S.getLangOpts().ObjCAutoRefCount)
1240       CheckKeyForObjCARCConversion(S, ResultType,
1241                                    RefExpr->getKeyExpr());
1242     return false;
1243   }
1244   bool arrayRef = (Res == Sema::OS_Array);
1245 
1246   if (ResultType.isNull()) {
1247     S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_base_type)
1248       << BaseExpr->getType() << arrayRef;
1249     return false;
1250   }
1251 
1252   if (!arrayRef) {
1253     // dictionary subscripting.
1254     // - (void)setObject:(id)object forKeyedSubscript:(id)key;
1255     IdentifierInfo *KeyIdents[] = {
1256       &S.Context.Idents.get("setObject"),
1257       &S.Context.Idents.get("forKeyedSubscript")
1258     };
1259     AtIndexSetterSelector = S.Context.Selectors.getSelector(2, KeyIdents);
1260   }
1261   else {
1262     // - (void)setObject:(id)object atIndexedSubscript:(NSInteger)index;
1263     IdentifierInfo *KeyIdents[] = {
1264       &S.Context.Idents.get("setObject"),
1265       &S.Context.Idents.get("atIndexedSubscript")
1266     };
1267     AtIndexSetterSelector = S.Context.Selectors.getSelector(2, KeyIdents);
1268   }
1269   AtIndexSetter = S.LookupMethodInObjectType(AtIndexSetterSelector, ResultType,
1270                                              true /*instance*/);
1271 
1272   bool receiverIdType = (BaseT->isObjCIdType() ||
1273                          BaseT->isObjCQualifiedIdType());
1274 
1275   if (!AtIndexSetter && S.getLangOpts().DebuggerObjCLiteral) {
1276     TypeSourceInfo *ReturnTInfo = nullptr;
1277     QualType ReturnType = S.Context.VoidTy;
1278     AtIndexSetter = ObjCMethodDecl::Create(
1279         S.Context, SourceLocation(), SourceLocation(), AtIndexSetterSelector,
1280         ReturnType, ReturnTInfo, S.Context.getTranslationUnitDecl(),
1281         true /*Instance*/, false /*isVariadic*/,
1282         /*isPropertyAccessor=*/false,
1283         /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
1284         ObjCMethodDecl::Required, false);
1285     SmallVector<ParmVarDecl *, 2> Params;
1286     ParmVarDecl *object = ParmVarDecl::Create(S.Context, AtIndexSetter,
1287                                                 SourceLocation(), SourceLocation(),
1288                                                 &S.Context.Idents.get("object"),
1289                                                 S.Context.getObjCIdType(),
1290                                                 /*TInfo=*/nullptr,
1291                                                 SC_None,
1292                                                 nullptr);
1293     Params.push_back(object);
1294     ParmVarDecl *key = ParmVarDecl::Create(S.Context, AtIndexSetter,
1295                                                 SourceLocation(), SourceLocation(),
1296                                                 arrayRef ?  &S.Context.Idents.get("index")
1297                                                          :  &S.Context.Idents.get("key"),
1298                                                 arrayRef ? S.Context.UnsignedLongTy
1299                                                          : S.Context.getObjCIdType(),
1300                                                 /*TInfo=*/nullptr,
1301                                                 SC_None,
1302                                                 nullptr);
1303     Params.push_back(key);
1304     AtIndexSetter->setMethodParams(S.Context, Params, None);
1305   }
1306 
1307   if (!AtIndexSetter) {
1308     if (!receiverIdType) {
1309       S.Diag(BaseExpr->getExprLoc(),
1310              diag::err_objc_subscript_method_not_found)
1311       << BaseExpr->getType() << 1 << arrayRef;
1312       return false;
1313     }
1314     AtIndexSetter =
1315       S.LookupInstanceMethodInGlobalPool(AtIndexSetterSelector,
1316                                          RefExpr->getSourceRange(),
1317                                          true);
1318   }
1319 
1320   bool err = false;
1321   if (AtIndexSetter && arrayRef) {
1322     QualType T = AtIndexSetter->parameters()[1]->getType();
1323     if (!T->isIntegralOrEnumerationType()) {
1324       S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1325              diag::err_objc_subscript_index_type) << T;
1326       S.Diag(AtIndexSetter->parameters()[1]->getLocation(),
1327              diag::note_parameter_type) << T;
1328       err = true;
1329     }
1330     T = AtIndexSetter->parameters()[0]->getType();
1331     if (!T->isObjCObjectPointerType()) {
1332       S.Diag(RefExpr->getBaseExpr()->getExprLoc(),
1333              diag::err_objc_subscript_object_type) << T << arrayRef;
1334       S.Diag(AtIndexSetter->parameters()[0]->getLocation(),
1335              diag::note_parameter_type) << T;
1336       err = true;
1337     }
1338   }
1339   else if (AtIndexSetter && !arrayRef)
1340     for (unsigned i=0; i <2; i++) {
1341       QualType T = AtIndexSetter->parameters()[i]->getType();
1342       if (!T->isObjCObjectPointerType()) {
1343         if (i == 1)
1344           S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1345                  diag::err_objc_subscript_key_type) << T;
1346         else
1347           S.Diag(RefExpr->getBaseExpr()->getExprLoc(),
1348                  diag::err_objc_subscript_dic_object_type) << T;
1349         S.Diag(AtIndexSetter->parameters()[i]->getLocation(),
1350                diag::note_parameter_type) << T;
1351         err = true;
1352       }
1353     }
1354 
1355   return !err;
1356 }
1357 
1358 // Get the object at "Index" position in the container.
1359 // [BaseExpr objectAtIndexedSubscript : IndexExpr];
buildGet()1360 ExprResult ObjCSubscriptOpBuilder::buildGet() {
1361   if (!findAtIndexGetter())
1362     return ExprError();
1363 
1364   QualType receiverType = InstanceBase->getType();
1365 
1366   // Build a message-send.
1367   ExprResult msg;
1368   Expr *Index = InstanceKey;
1369 
1370   // Arguments.
1371   Expr *args[] = { Index };
1372   assert(InstanceBase);
1373   if (AtIndexGetter)
1374     S.DiagnoseUseOfDecl(AtIndexGetter, GenericLoc);
1375   msg = S.BuildInstanceMessageImplicit(InstanceBase, receiverType,
1376                                        GenericLoc,
1377                                        AtIndexGetterSelector, AtIndexGetter,
1378                                        MultiExprArg(args, 1));
1379   return msg;
1380 }
1381 
1382 /// Store into the container the "op" object at "Index"'ed location
1383 /// by building this messaging expression:
1384 /// - (void)setObject:(id)object atIndexedSubscript:(NSInteger)index;
1385 /// \param captureSetValueAsResult If true, capture the actual
1386 ///   value being set as the value of the property operation.
buildSet(Expr * op,SourceLocation opcLoc,bool captureSetValueAsResult)1387 ExprResult ObjCSubscriptOpBuilder::buildSet(Expr *op, SourceLocation opcLoc,
1388                                            bool captureSetValueAsResult) {
1389   if (!findAtIndexSetter())
1390     return ExprError();
1391   if (AtIndexSetter)
1392     S.DiagnoseUseOfDecl(AtIndexSetter, GenericLoc);
1393   QualType receiverType = InstanceBase->getType();
1394   Expr *Index = InstanceKey;
1395 
1396   // Arguments.
1397   Expr *args[] = { op, Index };
1398 
1399   // Build a message-send.
1400   ExprResult msg = S.BuildInstanceMessageImplicit(InstanceBase, receiverType,
1401                                                   GenericLoc,
1402                                                   AtIndexSetterSelector,
1403                                                   AtIndexSetter,
1404                                                   MultiExprArg(args, 2));
1405 
1406   if (!msg.isInvalid() && captureSetValueAsResult) {
1407     ObjCMessageExpr *msgExpr =
1408       cast<ObjCMessageExpr>(msg.get()->IgnoreImplicit());
1409     Expr *arg = msgExpr->getArg(0);
1410     if (CanCaptureValue(arg))
1411       msgExpr->setArg(0, captureValueAsResult(arg));
1412   }
1413 
1414   return msg;
1415 }
1416 
1417 //===----------------------------------------------------------------------===//
1418 //  MSVC __declspec(property) references
1419 //===----------------------------------------------------------------------===//
1420 
rebuildAndCaptureObject(Expr * syntacticBase)1421 Expr *MSPropertyOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
1422   Expr *NewBase = capture(RefExpr->getBaseExpr());
1423 
1424   syntacticBase =
1425     MSPropertyRefRebuilder(S, NewBase).rebuild(syntacticBase);
1426 
1427   return syntacticBase;
1428 }
1429 
buildGet()1430 ExprResult MSPropertyOpBuilder::buildGet() {
1431   if (!RefExpr->getPropertyDecl()->hasGetter()) {
1432     S.Diag(RefExpr->getMemberLoc(), diag::err_no_accessor_for_property)
1433       << 0 /* getter */ << RefExpr->getPropertyDecl();
1434     return ExprError();
1435   }
1436 
1437   UnqualifiedId GetterName;
1438   IdentifierInfo *II = RefExpr->getPropertyDecl()->getGetterId();
1439   GetterName.setIdentifier(II, RefExpr->getMemberLoc());
1440   CXXScopeSpec SS;
1441   SS.Adopt(RefExpr->getQualifierLoc());
1442   ExprResult GetterExpr = S.ActOnMemberAccessExpr(
1443     S.getCurScope(), RefExpr->getBaseExpr(), SourceLocation(),
1444     RefExpr->isArrow() ? tok::arrow : tok::period, SS, SourceLocation(),
1445     GetterName, nullptr);
1446   if (GetterExpr.isInvalid()) {
1447     S.Diag(RefExpr->getMemberLoc(),
1448            diag::error_cannot_find_suitable_accessor) << 0 /* getter */
1449       << RefExpr->getPropertyDecl();
1450     return ExprError();
1451   }
1452 
1453   MultiExprArg ArgExprs;
1454   return S.ActOnCallExpr(S.getCurScope(), GetterExpr.get(),
1455                          RefExpr->getSourceRange().getBegin(), ArgExprs,
1456                          RefExpr->getSourceRange().getEnd());
1457 }
1458 
buildSet(Expr * op,SourceLocation sl,bool captureSetValueAsResult)1459 ExprResult MSPropertyOpBuilder::buildSet(Expr *op, SourceLocation sl,
1460                                          bool captureSetValueAsResult) {
1461   if (!RefExpr->getPropertyDecl()->hasSetter()) {
1462     S.Diag(RefExpr->getMemberLoc(), diag::err_no_accessor_for_property)
1463       << 1 /* setter */ << RefExpr->getPropertyDecl();
1464     return ExprError();
1465   }
1466 
1467   UnqualifiedId SetterName;
1468   IdentifierInfo *II = RefExpr->getPropertyDecl()->getSetterId();
1469   SetterName.setIdentifier(II, RefExpr->getMemberLoc());
1470   CXXScopeSpec SS;
1471   SS.Adopt(RefExpr->getQualifierLoc());
1472   ExprResult SetterExpr = S.ActOnMemberAccessExpr(
1473     S.getCurScope(), RefExpr->getBaseExpr(), SourceLocation(),
1474     RefExpr->isArrow() ? tok::arrow : tok::period, SS, SourceLocation(),
1475     SetterName, nullptr);
1476   if (SetterExpr.isInvalid()) {
1477     S.Diag(RefExpr->getMemberLoc(),
1478            diag::error_cannot_find_suitable_accessor) << 1 /* setter */
1479       << RefExpr->getPropertyDecl();
1480     return ExprError();
1481   }
1482 
1483   SmallVector<Expr*, 1> ArgExprs;
1484   ArgExprs.push_back(op);
1485   return S.ActOnCallExpr(S.getCurScope(), SetterExpr.get(),
1486                          RefExpr->getSourceRange().getBegin(), ArgExprs,
1487                          op->getSourceRange().getEnd());
1488 }
1489 
1490 //===----------------------------------------------------------------------===//
1491 //  General Sema routines.
1492 //===----------------------------------------------------------------------===//
1493 
checkPseudoObjectRValue(Expr * E)1494 ExprResult Sema::checkPseudoObjectRValue(Expr *E) {
1495   Expr *opaqueRef = E->IgnoreParens();
1496   if (ObjCPropertyRefExpr *refExpr
1497         = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1498     ObjCPropertyOpBuilder builder(*this, refExpr);
1499     return builder.buildRValueOperation(E);
1500   }
1501   else if (ObjCSubscriptRefExpr *refExpr
1502            = dyn_cast<ObjCSubscriptRefExpr>(opaqueRef)) {
1503     ObjCSubscriptOpBuilder builder(*this, refExpr);
1504     return builder.buildRValueOperation(E);
1505   } else if (MSPropertyRefExpr *refExpr
1506              = dyn_cast<MSPropertyRefExpr>(opaqueRef)) {
1507     MSPropertyOpBuilder builder(*this, refExpr);
1508     return builder.buildRValueOperation(E);
1509   } else {
1510     llvm_unreachable("unknown pseudo-object kind!");
1511   }
1512 }
1513 
1514 /// Check an increment or decrement of a pseudo-object expression.
checkPseudoObjectIncDec(Scope * Sc,SourceLocation opcLoc,UnaryOperatorKind opcode,Expr * op)1515 ExprResult Sema::checkPseudoObjectIncDec(Scope *Sc, SourceLocation opcLoc,
1516                                          UnaryOperatorKind opcode, Expr *op) {
1517   // Do nothing if the operand is dependent.
1518   if (op->isTypeDependent())
1519     return new (Context) UnaryOperator(op, opcode, Context.DependentTy,
1520                                        VK_RValue, OK_Ordinary, opcLoc);
1521 
1522   assert(UnaryOperator::isIncrementDecrementOp(opcode));
1523   Expr *opaqueRef = op->IgnoreParens();
1524   if (ObjCPropertyRefExpr *refExpr
1525         = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1526     ObjCPropertyOpBuilder builder(*this, refExpr);
1527     return builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1528   } else if (isa<ObjCSubscriptRefExpr>(opaqueRef)) {
1529     Diag(opcLoc, diag::err_illegal_container_subscripting_op);
1530     return ExprError();
1531   } else if (MSPropertyRefExpr *refExpr
1532              = dyn_cast<MSPropertyRefExpr>(opaqueRef)) {
1533     MSPropertyOpBuilder builder(*this, refExpr);
1534     return builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1535   } else {
1536     llvm_unreachable("unknown pseudo-object kind!");
1537   }
1538 }
1539 
checkPseudoObjectAssignment(Scope * S,SourceLocation opcLoc,BinaryOperatorKind opcode,Expr * LHS,Expr * RHS)1540 ExprResult Sema::checkPseudoObjectAssignment(Scope *S, SourceLocation opcLoc,
1541                                              BinaryOperatorKind opcode,
1542                                              Expr *LHS, Expr *RHS) {
1543   // Do nothing if either argument is dependent.
1544   if (LHS->isTypeDependent() || RHS->isTypeDependent())
1545     return new (Context) BinaryOperator(LHS, RHS, opcode, Context.DependentTy,
1546                                         VK_RValue, OK_Ordinary, opcLoc, false);
1547 
1548   // Filter out non-overload placeholder types in the RHS.
1549   if (RHS->getType()->isNonOverloadPlaceholderType()) {
1550     ExprResult result = CheckPlaceholderExpr(RHS);
1551     if (result.isInvalid()) return ExprError();
1552     RHS = result.get();
1553   }
1554 
1555   Expr *opaqueRef = LHS->IgnoreParens();
1556   if (ObjCPropertyRefExpr *refExpr
1557         = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1558     ObjCPropertyOpBuilder builder(*this, refExpr);
1559     return builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1560   } else if (ObjCSubscriptRefExpr *refExpr
1561              = dyn_cast<ObjCSubscriptRefExpr>(opaqueRef)) {
1562     ObjCSubscriptOpBuilder builder(*this, refExpr);
1563     return builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1564   } else if (MSPropertyRefExpr *refExpr
1565              = dyn_cast<MSPropertyRefExpr>(opaqueRef)) {
1566     MSPropertyOpBuilder builder(*this, refExpr);
1567     return builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1568   } else {
1569     llvm_unreachable("unknown pseudo-object kind!");
1570   }
1571 }
1572 
1573 /// Given a pseudo-object reference, rebuild it without the opaque
1574 /// values.  Basically, undo the behavior of rebuildAndCaptureObject.
1575 /// This should never operate in-place.
stripOpaqueValuesFromPseudoObjectRef(Sema & S,Expr * E)1576 static Expr *stripOpaqueValuesFromPseudoObjectRef(Sema &S, Expr *E) {
1577   Expr *opaqueRef = E->IgnoreParens();
1578   if (ObjCPropertyRefExpr *refExpr
1579         = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1580     // Class and super property references don't have opaque values in them.
1581     if (refExpr->isClassReceiver() || refExpr->isSuperReceiver())
1582       return E;
1583 
1584     assert(refExpr->isObjectReceiver() && "Unknown receiver kind?");
1585     OpaqueValueExpr *baseOVE = cast<OpaqueValueExpr>(refExpr->getBase());
1586     return ObjCPropertyRefRebuilder(S, baseOVE->getSourceExpr()).rebuild(E);
1587   } else if (ObjCSubscriptRefExpr *refExpr
1588                = dyn_cast<ObjCSubscriptRefExpr>(opaqueRef)) {
1589     OpaqueValueExpr *baseOVE = cast<OpaqueValueExpr>(refExpr->getBaseExpr());
1590     OpaqueValueExpr *keyOVE = cast<OpaqueValueExpr>(refExpr->getKeyExpr());
1591     return ObjCSubscriptRefRebuilder(S, baseOVE->getSourceExpr(),
1592                                      keyOVE->getSourceExpr()).rebuild(E);
1593   } else if (MSPropertyRefExpr *refExpr
1594              = dyn_cast<MSPropertyRefExpr>(opaqueRef)) {
1595     OpaqueValueExpr *baseOVE = cast<OpaqueValueExpr>(refExpr->getBaseExpr());
1596     return MSPropertyRefRebuilder(S, baseOVE->getSourceExpr()).rebuild(E);
1597   } else {
1598     llvm_unreachable("unknown pseudo-object kind!");
1599   }
1600 }
1601 
1602 /// Given a pseudo-object expression, recreate what it looks like
1603 /// syntactically without the attendant OpaqueValueExprs.
1604 ///
1605 /// This is a hack which should be removed when TreeTransform is
1606 /// capable of rebuilding a tree without stripping implicit
1607 /// operations.
recreateSyntacticForm(PseudoObjectExpr * E)1608 Expr *Sema::recreateSyntacticForm(PseudoObjectExpr *E) {
1609   Expr *syntax = E->getSyntacticForm();
1610   if (UnaryOperator *uop = dyn_cast<UnaryOperator>(syntax)) {
1611     Expr *op = stripOpaqueValuesFromPseudoObjectRef(*this, uop->getSubExpr());
1612     return new (Context) UnaryOperator(op, uop->getOpcode(), uop->getType(),
1613                                        uop->getValueKind(), uop->getObjectKind(),
1614                                        uop->getOperatorLoc());
1615   } else if (CompoundAssignOperator *cop
1616                = dyn_cast<CompoundAssignOperator>(syntax)) {
1617     Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, cop->getLHS());
1618     Expr *rhs = cast<OpaqueValueExpr>(cop->getRHS())->getSourceExpr();
1619     return new (Context) CompoundAssignOperator(lhs, rhs, cop->getOpcode(),
1620                                                 cop->getType(),
1621                                                 cop->getValueKind(),
1622                                                 cop->getObjectKind(),
1623                                                 cop->getComputationLHSType(),
1624                                                 cop->getComputationResultType(),
1625                                                 cop->getOperatorLoc(), false);
1626   } else if (BinaryOperator *bop = dyn_cast<BinaryOperator>(syntax)) {
1627     Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, bop->getLHS());
1628     Expr *rhs = cast<OpaqueValueExpr>(bop->getRHS())->getSourceExpr();
1629     return new (Context) BinaryOperator(lhs, rhs, bop->getOpcode(),
1630                                         bop->getType(), bop->getValueKind(),
1631                                         bop->getObjectKind(),
1632                                         bop->getOperatorLoc(), false);
1633   } else {
1634     assert(syntax->hasPlaceholderType(BuiltinType::PseudoObject));
1635     return stripOpaqueValuesFromPseudoObjectRef(*this, syntax);
1636   }
1637 }
1638