• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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   struct Rebuilder {
48     Sema &S;
49     unsigned MSPropertySubscriptCount;
50     typedef llvm::function_ref<Expr *(Expr *, unsigned)> SpecificRebuilderRefTy;
51     const SpecificRebuilderRefTy &SpecificCallback;
Rebuilder__anonfe1523870111::Rebuilder52     Rebuilder(Sema &S, const SpecificRebuilderRefTy &SpecificCallback)
53         : S(S), MSPropertySubscriptCount(0),
54           SpecificCallback(SpecificCallback) {}
55 
rebuildObjCPropertyRefExpr__anonfe1523870111::Rebuilder56     Expr *rebuildObjCPropertyRefExpr(ObjCPropertyRefExpr *refExpr) {
57       // Fortunately, the constraint that we're rebuilding something
58       // with a base limits the number of cases here.
59       if (refExpr->isClassReceiver() || refExpr->isSuperReceiver())
60         return refExpr;
61 
62       if (refExpr->isExplicitProperty()) {
63         return new (S.Context) ObjCPropertyRefExpr(
64             refExpr->getExplicitProperty(), refExpr->getType(),
65             refExpr->getValueKind(), refExpr->getObjectKind(),
66             refExpr->getLocation(), SpecificCallback(refExpr->getBase(), 0));
67       }
68       return new (S.Context) ObjCPropertyRefExpr(
69           refExpr->getImplicitPropertyGetter(),
70           refExpr->getImplicitPropertySetter(), refExpr->getType(),
71           refExpr->getValueKind(), refExpr->getObjectKind(),
72           refExpr->getLocation(), SpecificCallback(refExpr->getBase(), 0));
73     }
rebuildObjCSubscriptRefExpr__anonfe1523870111::Rebuilder74     Expr *rebuildObjCSubscriptRefExpr(ObjCSubscriptRefExpr *refExpr) {
75       assert(refExpr->getBaseExpr());
76       assert(refExpr->getKeyExpr());
77 
78       return new (S.Context) ObjCSubscriptRefExpr(
79           SpecificCallback(refExpr->getBaseExpr(), 0),
80           SpecificCallback(refExpr->getKeyExpr(), 1), refExpr->getType(),
81           refExpr->getValueKind(), refExpr->getObjectKind(),
82           refExpr->getAtIndexMethodDecl(), refExpr->setAtIndexMethodDecl(),
83           refExpr->getRBracket());
84     }
rebuildMSPropertyRefExpr__anonfe1523870111::Rebuilder85     Expr *rebuildMSPropertyRefExpr(MSPropertyRefExpr *refExpr) {
86       assert(refExpr->getBaseExpr());
87 
88       return new (S.Context) MSPropertyRefExpr(
89           SpecificCallback(refExpr->getBaseExpr(), 0),
90           refExpr->getPropertyDecl(), refExpr->isArrow(), refExpr->getType(),
91           refExpr->getValueKind(), refExpr->getQualifierLoc(),
92           refExpr->getMemberLoc());
93     }
rebuildMSPropertySubscriptExpr__anonfe1523870111::Rebuilder94     Expr *rebuildMSPropertySubscriptExpr(MSPropertySubscriptExpr *refExpr) {
95       assert(refExpr->getBase());
96       assert(refExpr->getIdx());
97 
98       auto *NewBase = rebuild(refExpr->getBase());
99       ++MSPropertySubscriptCount;
100       return new (S.Context) MSPropertySubscriptExpr(
101           NewBase,
102           SpecificCallback(refExpr->getIdx(), MSPropertySubscriptCount),
103           refExpr->getType(), refExpr->getValueKind(), refExpr->getObjectKind(),
104           refExpr->getRBracketLoc());
105     }
106 
rebuild__anonfe1523870111::Rebuilder107     Expr *rebuild(Expr *e) {
108       // Fast path: nothing to look through.
109       if (auto *PRE = dyn_cast<ObjCPropertyRefExpr>(e))
110         return rebuildObjCPropertyRefExpr(PRE);
111       if (auto *SRE = dyn_cast<ObjCSubscriptRefExpr>(e))
112         return rebuildObjCSubscriptRefExpr(SRE);
113       if (auto *MSPRE = dyn_cast<MSPropertyRefExpr>(e))
114         return rebuildMSPropertyRefExpr(MSPRE);
115       if (auto *MSPSE = dyn_cast<MSPropertySubscriptExpr>(e))
116         return rebuildMSPropertySubscriptExpr(MSPSE);
117 
118       // Otherwise, we should look through and rebuild anything that
119       // IgnoreParens would.
120 
121       if (ParenExpr *parens = dyn_cast<ParenExpr>(e)) {
122         e = rebuild(parens->getSubExpr());
123         return new (S.Context) ParenExpr(parens->getLParen(),
124                                          parens->getRParen(),
125                                          e);
126       }
127 
128       if (UnaryOperator *uop = dyn_cast<UnaryOperator>(e)) {
129         assert(uop->getOpcode() == UO_Extension);
130         e = rebuild(uop->getSubExpr());
131         return new (S.Context) UnaryOperator(e, uop->getOpcode(),
132                                              uop->getType(),
133                                              uop->getValueKind(),
134                                              uop->getObjectKind(),
135                                              uop->getOperatorLoc());
136       }
137 
138       if (GenericSelectionExpr *gse = dyn_cast<GenericSelectionExpr>(e)) {
139         assert(!gse->isResultDependent());
140         unsigned resultIndex = gse->getResultIndex();
141         unsigned numAssocs = gse->getNumAssocs();
142 
143         SmallVector<Expr*, 8> assocs(numAssocs);
144         SmallVector<TypeSourceInfo*, 8> assocTypes(numAssocs);
145 
146         for (unsigned i = 0; i != numAssocs; ++i) {
147           Expr *assoc = gse->getAssocExpr(i);
148           if (i == resultIndex) assoc = rebuild(assoc);
149           assocs[i] = assoc;
150           assocTypes[i] = gse->getAssocTypeSourceInfo(i);
151         }
152 
153         return new (S.Context) GenericSelectionExpr(S.Context,
154                                                     gse->getGenericLoc(),
155                                                     gse->getControllingExpr(),
156                                                     assocTypes,
157                                                     assocs,
158                                                     gse->getDefaultLoc(),
159                                                     gse->getRParenLoc(),
160                                       gse->containsUnexpandedParameterPack(),
161                                                     resultIndex);
162       }
163 
164       if (ChooseExpr *ce = dyn_cast<ChooseExpr>(e)) {
165         assert(!ce->isConditionDependent());
166 
167         Expr *LHS = ce->getLHS(), *RHS = ce->getRHS();
168         Expr *&rebuiltExpr = ce->isConditionTrue() ? LHS : RHS;
169         rebuiltExpr = rebuild(rebuiltExpr);
170 
171         return new (S.Context) ChooseExpr(ce->getBuiltinLoc(),
172                                           ce->getCond(),
173                                           LHS, RHS,
174                                           rebuiltExpr->getType(),
175                                           rebuiltExpr->getValueKind(),
176                                           rebuiltExpr->getObjectKind(),
177                                           ce->getRParenLoc(),
178                                           ce->isConditionTrue(),
179                                           rebuiltExpr->isTypeDependent(),
180                                           rebuiltExpr->isValueDependent());
181       }
182 
183       llvm_unreachable("bad expression to rebuild!");
184     }
185   };
186 
187   class PseudoOpBuilder {
188   public:
189     Sema &S;
190     unsigned ResultIndex;
191     SourceLocation GenericLoc;
192     SmallVector<Expr *, 4> Semantics;
193 
PseudoOpBuilder(Sema & S,SourceLocation genericLoc)194     PseudoOpBuilder(Sema &S, SourceLocation genericLoc)
195       : S(S), ResultIndex(PseudoObjectExpr::NoResult),
196         GenericLoc(genericLoc) {}
197 
~PseudoOpBuilder()198     virtual ~PseudoOpBuilder() {}
199 
200     /// Add a normal semantic expression.
addSemanticExpr(Expr * semantic)201     void addSemanticExpr(Expr *semantic) {
202       Semantics.push_back(semantic);
203     }
204 
205     /// Add the 'result' semantic expression.
addResultSemanticExpr(Expr * resultExpr)206     void addResultSemanticExpr(Expr *resultExpr) {
207       assert(ResultIndex == PseudoObjectExpr::NoResult);
208       ResultIndex = Semantics.size();
209       Semantics.push_back(resultExpr);
210     }
211 
212     ExprResult buildRValueOperation(Expr *op);
213     ExprResult buildAssignmentOperation(Scope *Sc,
214                                         SourceLocation opLoc,
215                                         BinaryOperatorKind opcode,
216                                         Expr *LHS, Expr *RHS);
217     ExprResult buildIncDecOperation(Scope *Sc, SourceLocation opLoc,
218                                     UnaryOperatorKind opcode,
219                                     Expr *op);
220 
221     virtual ExprResult complete(Expr *syntacticForm);
222 
223     OpaqueValueExpr *capture(Expr *op);
224     OpaqueValueExpr *captureValueAsResult(Expr *op);
225 
setResultToLastSemantic()226     void setResultToLastSemantic() {
227       assert(ResultIndex == PseudoObjectExpr::NoResult);
228       ResultIndex = Semantics.size() - 1;
229     }
230 
231     /// Return true if assignments have a non-void result.
CanCaptureValue(Expr * exp)232     static bool CanCaptureValue(Expr *exp) {
233       if (exp->isGLValue())
234         return true;
235       QualType ty = exp->getType();
236       assert(!ty->isIncompleteType());
237       assert(!ty->isDependentType());
238 
239       if (const CXXRecordDecl *ClassDecl = ty->getAsCXXRecordDecl())
240         return ClassDecl->isTriviallyCopyable();
241       return true;
242     }
243 
244     virtual Expr *rebuildAndCaptureObject(Expr *) = 0;
245     virtual ExprResult buildGet() = 0;
246     virtual ExprResult buildSet(Expr *, SourceLocation,
247                                 bool captureSetValueAsResult) = 0;
248     /// \brief Should the result of an assignment be the formal result of the
249     /// setter call or the value that was passed to the setter?
250     ///
251     /// Different pseudo-object language features use different language rules
252     /// for this.
253     /// The default is to use the set value.  Currently, this affects the
254     /// behavior of simple assignments, compound assignments, and prefix
255     /// increment and decrement.
256     /// Postfix increment and decrement always use the getter result as the
257     /// expression result.
258     ///
259     /// If this method returns true, and the set value isn't capturable for
260     /// some reason, the result of the expression will be void.
captureSetValueAsResult() const261     virtual bool captureSetValueAsResult() const { return true; }
262   };
263 
264   /// A PseudoOpBuilder for Objective-C \@properties.
265   class ObjCPropertyOpBuilder : public PseudoOpBuilder {
266     ObjCPropertyRefExpr *RefExpr;
267     ObjCPropertyRefExpr *SyntacticRefExpr;
268     OpaqueValueExpr *InstanceReceiver;
269     ObjCMethodDecl *Getter;
270 
271     ObjCMethodDecl *Setter;
272     Selector SetterSelector;
273     Selector GetterSelector;
274 
275   public:
ObjCPropertyOpBuilder(Sema & S,ObjCPropertyRefExpr * refExpr)276     ObjCPropertyOpBuilder(Sema &S, ObjCPropertyRefExpr *refExpr) :
277       PseudoOpBuilder(S, refExpr->getLocation()), RefExpr(refExpr),
278       SyntacticRefExpr(nullptr), InstanceReceiver(nullptr), Getter(nullptr),
279       Setter(nullptr) {
280     }
281 
282     ExprResult buildRValueOperation(Expr *op);
283     ExprResult buildAssignmentOperation(Scope *Sc,
284                                         SourceLocation opLoc,
285                                         BinaryOperatorKind opcode,
286                                         Expr *LHS, Expr *RHS);
287     ExprResult buildIncDecOperation(Scope *Sc, SourceLocation opLoc,
288                                     UnaryOperatorKind opcode,
289                                     Expr *op);
290 
291     bool tryBuildGetOfReference(Expr *op, ExprResult &result);
292     bool findSetter(bool warn=true);
293     bool findGetter();
294     void DiagnoseUnsupportedPropertyUse();
295 
296     Expr *rebuildAndCaptureObject(Expr *syntacticBase) override;
297     ExprResult buildGet() override;
298     ExprResult buildSet(Expr *op, SourceLocation, bool) override;
299     ExprResult complete(Expr *SyntacticForm) override;
300 
301     bool isWeakProperty() const;
302   };
303 
304  /// A PseudoOpBuilder for Objective-C array/dictionary indexing.
305  class ObjCSubscriptOpBuilder : public PseudoOpBuilder {
306    ObjCSubscriptRefExpr *RefExpr;
307    OpaqueValueExpr *InstanceBase;
308    OpaqueValueExpr *InstanceKey;
309    ObjCMethodDecl *AtIndexGetter;
310    Selector AtIndexGetterSelector;
311 
312    ObjCMethodDecl *AtIndexSetter;
313    Selector AtIndexSetterSelector;
314 
315  public:
ObjCSubscriptOpBuilder(Sema & S,ObjCSubscriptRefExpr * refExpr)316     ObjCSubscriptOpBuilder(Sema &S, ObjCSubscriptRefExpr *refExpr) :
317       PseudoOpBuilder(S, refExpr->getSourceRange().getBegin()),
318       RefExpr(refExpr),
319       InstanceBase(nullptr), InstanceKey(nullptr),
320       AtIndexGetter(nullptr), AtIndexSetter(nullptr) {}
321 
322    ExprResult buildRValueOperation(Expr *op);
323    ExprResult buildAssignmentOperation(Scope *Sc,
324                                        SourceLocation opLoc,
325                                        BinaryOperatorKind opcode,
326                                        Expr *LHS, Expr *RHS);
327    Expr *rebuildAndCaptureObject(Expr *syntacticBase) override;
328 
329    bool findAtIndexGetter();
330    bool findAtIndexSetter();
331 
332    ExprResult buildGet() override;
333    ExprResult buildSet(Expr *op, SourceLocation, bool) override;
334  };
335 
336  class MSPropertyOpBuilder : public PseudoOpBuilder {
337    MSPropertyRefExpr *RefExpr;
338    OpaqueValueExpr *InstanceBase;
339    SmallVector<Expr *, 4> CallArgs;
340 
341    MSPropertyRefExpr *getBaseMSProperty(MSPropertySubscriptExpr *E);
342 
343  public:
MSPropertyOpBuilder(Sema & S,MSPropertyRefExpr * refExpr)344    MSPropertyOpBuilder(Sema &S, MSPropertyRefExpr *refExpr) :
345      PseudoOpBuilder(S, refExpr->getSourceRange().getBegin()),
346      RefExpr(refExpr), InstanceBase(nullptr) {}
MSPropertyOpBuilder(Sema & S,MSPropertySubscriptExpr * refExpr)347    MSPropertyOpBuilder(Sema &S, MSPropertySubscriptExpr *refExpr)
348        : PseudoOpBuilder(S, refExpr->getSourceRange().getBegin()),
349          InstanceBase(nullptr) {
350      RefExpr = getBaseMSProperty(refExpr);
351    }
352 
353    Expr *rebuildAndCaptureObject(Expr *) override;
354    ExprResult buildGet() override;
355    ExprResult buildSet(Expr *op, SourceLocation, bool) override;
captureSetValueAsResult() const356    bool captureSetValueAsResult() const override { return false; }
357  };
358 }
359 
360 /// Capture the given expression in an OpaqueValueExpr.
capture(Expr * e)361 OpaqueValueExpr *PseudoOpBuilder::capture(Expr *e) {
362   // Make a new OVE whose source is the given expression.
363   OpaqueValueExpr *captured =
364     new (S.Context) OpaqueValueExpr(GenericLoc, e->getType(),
365                                     e->getValueKind(), e->getObjectKind(),
366                                     e);
367 
368   // Make sure we bind that in the semantics.
369   addSemanticExpr(captured);
370   return captured;
371 }
372 
373 /// Capture the given expression as the result of this pseudo-object
374 /// operation.  This routine is safe against expressions which may
375 /// already be captured.
376 ///
377 /// \returns the captured expression, which will be the
378 ///   same as the input if the input was already captured
captureValueAsResult(Expr * e)379 OpaqueValueExpr *PseudoOpBuilder::captureValueAsResult(Expr *e) {
380   assert(ResultIndex == PseudoObjectExpr::NoResult);
381 
382   // If the expression hasn't already been captured, just capture it
383   // and set the new semantic
384   if (!isa<OpaqueValueExpr>(e)) {
385     OpaqueValueExpr *cap = capture(e);
386     setResultToLastSemantic();
387     return cap;
388   }
389 
390   // Otherwise, it must already be one of our semantic expressions;
391   // set ResultIndex to its index.
392   unsigned index = 0;
393   for (;; ++index) {
394     assert(index < Semantics.size() &&
395            "captured expression not found in semantics!");
396     if (e == Semantics[index]) break;
397   }
398   ResultIndex = index;
399   return cast<OpaqueValueExpr>(e);
400 }
401 
402 /// The routine which creates the final PseudoObjectExpr.
complete(Expr * syntactic)403 ExprResult PseudoOpBuilder::complete(Expr *syntactic) {
404   return PseudoObjectExpr::Create(S.Context, syntactic,
405                                   Semantics, ResultIndex);
406 }
407 
408 /// The main skeleton for building an r-value operation.
buildRValueOperation(Expr * op)409 ExprResult PseudoOpBuilder::buildRValueOperation(Expr *op) {
410   Expr *syntacticBase = rebuildAndCaptureObject(op);
411 
412   ExprResult getExpr = buildGet();
413   if (getExpr.isInvalid()) return ExprError();
414   addResultSemanticExpr(getExpr.get());
415 
416   return complete(syntacticBase);
417 }
418 
419 /// The basic skeleton for building a simple or compound
420 /// assignment operation.
421 ExprResult
buildAssignmentOperation(Scope * Sc,SourceLocation opcLoc,BinaryOperatorKind opcode,Expr * LHS,Expr * RHS)422 PseudoOpBuilder::buildAssignmentOperation(Scope *Sc, SourceLocation opcLoc,
423                                           BinaryOperatorKind opcode,
424                                           Expr *LHS, Expr *RHS) {
425   assert(BinaryOperator::isAssignmentOp(opcode));
426 
427   Expr *syntacticLHS = rebuildAndCaptureObject(LHS);
428   OpaqueValueExpr *capturedRHS = capture(RHS);
429 
430   // In some very specific cases, semantic analysis of the RHS as an
431   // expression may require it to be rewritten.  In these cases, we
432   // cannot safely keep the OVE around.  Fortunately, we don't really
433   // need to: we don't use this particular OVE in multiple places, and
434   // no clients rely that closely on matching up expressions in the
435   // semantic expression with expressions from the syntactic form.
436   Expr *semanticRHS = capturedRHS;
437   if (RHS->hasPlaceholderType() || isa<InitListExpr>(RHS)) {
438     semanticRHS = RHS;
439     Semantics.pop_back();
440   }
441 
442   Expr *syntactic;
443 
444   ExprResult result;
445   if (opcode == BO_Assign) {
446     result = semanticRHS;
447     syntactic = new (S.Context) BinaryOperator(syntacticLHS, capturedRHS,
448                                                opcode, capturedRHS->getType(),
449                                                capturedRHS->getValueKind(),
450                                                OK_Ordinary, opcLoc, false);
451   } else {
452     ExprResult opLHS = buildGet();
453     if (opLHS.isInvalid()) return ExprError();
454 
455     // Build an ordinary, non-compound operation.
456     BinaryOperatorKind nonCompound =
457       BinaryOperator::getOpForCompoundAssignment(opcode);
458     result = S.BuildBinOp(Sc, opcLoc, nonCompound, opLHS.get(), semanticRHS);
459     if (result.isInvalid()) return ExprError();
460 
461     syntactic =
462       new (S.Context) CompoundAssignOperator(syntacticLHS, capturedRHS, opcode,
463                                              result.get()->getType(),
464                                              result.get()->getValueKind(),
465                                              OK_Ordinary,
466                                              opLHS.get()->getType(),
467                                              result.get()->getType(),
468                                              opcLoc, false);
469   }
470 
471   // The result of the assignment, if not void, is the value set into
472   // the l-value.
473   result = buildSet(result.get(), opcLoc, captureSetValueAsResult());
474   if (result.isInvalid()) return ExprError();
475   addSemanticExpr(result.get());
476   if (!captureSetValueAsResult() && !result.get()->getType()->isVoidType() &&
477       (result.get()->isTypeDependent() || CanCaptureValue(result.get())))
478     setResultToLastSemantic();
479 
480   return complete(syntactic);
481 }
482 
483 /// The basic skeleton for building an increment or decrement
484 /// operation.
485 ExprResult
buildIncDecOperation(Scope * Sc,SourceLocation opcLoc,UnaryOperatorKind opcode,Expr * op)486 PseudoOpBuilder::buildIncDecOperation(Scope *Sc, SourceLocation opcLoc,
487                                       UnaryOperatorKind opcode,
488                                       Expr *op) {
489   assert(UnaryOperator::isIncrementDecrementOp(opcode));
490 
491   Expr *syntacticOp = rebuildAndCaptureObject(op);
492 
493   // Load the value.
494   ExprResult result = buildGet();
495   if (result.isInvalid()) return ExprError();
496 
497   QualType resultType = result.get()->getType();
498 
499   // That's the postfix result.
500   if (UnaryOperator::isPostfix(opcode) &&
501       (result.get()->isTypeDependent() || CanCaptureValue(result.get()))) {
502     result = capture(result.get());
503     setResultToLastSemantic();
504   }
505 
506   // Add or subtract a literal 1.
507   llvm::APInt oneV(S.Context.getTypeSize(S.Context.IntTy), 1);
508   Expr *one = IntegerLiteral::Create(S.Context, oneV, S.Context.IntTy,
509                                      GenericLoc);
510 
511   if (UnaryOperator::isIncrementOp(opcode)) {
512     result = S.BuildBinOp(Sc, opcLoc, BO_Add, result.get(), one);
513   } else {
514     result = S.BuildBinOp(Sc, opcLoc, BO_Sub, result.get(), one);
515   }
516   if (result.isInvalid()) return ExprError();
517 
518   // Store that back into the result.  The value stored is the result
519   // of a prefix operation.
520   result = buildSet(result.get(), opcLoc, UnaryOperator::isPrefix(opcode) &&
521                                               captureSetValueAsResult());
522   if (result.isInvalid()) return ExprError();
523   addSemanticExpr(result.get());
524   if (UnaryOperator::isPrefix(opcode) && !captureSetValueAsResult() &&
525       !result.get()->getType()->isVoidType() &&
526       (result.get()->isTypeDependent() || CanCaptureValue(result.get())))
527     setResultToLastSemantic();
528 
529   UnaryOperator *syntactic =
530     new (S.Context) UnaryOperator(syntacticOp, opcode, resultType,
531                                   VK_LValue, OK_Ordinary, opcLoc);
532   return complete(syntactic);
533 }
534 
535 
536 //===----------------------------------------------------------------------===//
537 //  Objective-C @property and implicit property references
538 //===----------------------------------------------------------------------===//
539 
540 /// Look up a method in the receiver type of an Objective-C property
541 /// reference.
LookupMethodInReceiverType(Sema & S,Selector sel,const ObjCPropertyRefExpr * PRE)542 static ObjCMethodDecl *LookupMethodInReceiverType(Sema &S, Selector sel,
543                                             const ObjCPropertyRefExpr *PRE) {
544   if (PRE->isObjectReceiver()) {
545     const ObjCObjectPointerType *PT =
546       PRE->getBase()->getType()->castAs<ObjCObjectPointerType>();
547 
548     // Special case for 'self' in class method implementations.
549     if (PT->isObjCClassType() &&
550         S.isSelfExpr(const_cast<Expr*>(PRE->getBase()))) {
551       // This cast is safe because isSelfExpr is only true within
552       // methods.
553       ObjCMethodDecl *method =
554         cast<ObjCMethodDecl>(S.CurContext->getNonClosureAncestor());
555       return S.LookupMethodInObjectType(sel,
556                  S.Context.getObjCInterfaceType(method->getClassInterface()),
557                                         /*instance*/ false);
558     }
559 
560     return S.LookupMethodInObjectType(sel, PT->getPointeeType(), true);
561   }
562 
563   if (PRE->isSuperReceiver()) {
564     if (const ObjCObjectPointerType *PT =
565         PRE->getSuperReceiverType()->getAs<ObjCObjectPointerType>())
566       return S.LookupMethodInObjectType(sel, PT->getPointeeType(), true);
567 
568     return S.LookupMethodInObjectType(sel, PRE->getSuperReceiverType(), false);
569   }
570 
571   assert(PRE->isClassReceiver() && "Invalid expression");
572   QualType IT = S.Context.getObjCInterfaceType(PRE->getClassReceiver());
573   return S.LookupMethodInObjectType(sel, IT, false);
574 }
575 
isWeakProperty() const576 bool ObjCPropertyOpBuilder::isWeakProperty() const {
577   QualType T;
578   if (RefExpr->isExplicitProperty()) {
579     const ObjCPropertyDecl *Prop = RefExpr->getExplicitProperty();
580     if (Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak)
581       return true;
582 
583     T = Prop->getType();
584   } else if (Getter) {
585     T = Getter->getReturnType();
586   } else {
587     return false;
588   }
589 
590   return T.getObjCLifetime() == Qualifiers::OCL_Weak;
591 }
592 
findGetter()593 bool ObjCPropertyOpBuilder::findGetter() {
594   if (Getter) return true;
595 
596   // For implicit properties, just trust the lookup we already did.
597   if (RefExpr->isImplicitProperty()) {
598     if ((Getter = RefExpr->getImplicitPropertyGetter())) {
599       GetterSelector = Getter->getSelector();
600       return true;
601     }
602     else {
603       // Must build the getter selector the hard way.
604       ObjCMethodDecl *setter = RefExpr->getImplicitPropertySetter();
605       assert(setter && "both setter and getter are null - cannot happen");
606       IdentifierInfo *setterName =
607         setter->getSelector().getIdentifierInfoForSlot(0);
608       IdentifierInfo *getterName =
609           &S.Context.Idents.get(setterName->getName().substr(3));
610       GetterSelector =
611         S.PP.getSelectorTable().getNullarySelector(getterName);
612       return false;
613     }
614   }
615 
616   ObjCPropertyDecl *prop = RefExpr->getExplicitProperty();
617   Getter = LookupMethodInReceiverType(S, prop->getGetterName(), RefExpr);
618   return (Getter != nullptr);
619 }
620 
621 /// Try to find the most accurate setter declaration for the property
622 /// reference.
623 ///
624 /// \return true if a setter was found, in which case Setter
findSetter(bool warn)625 bool ObjCPropertyOpBuilder::findSetter(bool warn) {
626   // For implicit properties, just trust the lookup we already did.
627   if (RefExpr->isImplicitProperty()) {
628     if (ObjCMethodDecl *setter = RefExpr->getImplicitPropertySetter()) {
629       Setter = setter;
630       SetterSelector = setter->getSelector();
631       return true;
632     } else {
633       IdentifierInfo *getterName =
634         RefExpr->getImplicitPropertyGetter()->getSelector()
635           .getIdentifierInfoForSlot(0);
636       SetterSelector =
637         SelectorTable::constructSetterSelector(S.PP.getIdentifierTable(),
638                                                S.PP.getSelectorTable(),
639                                                getterName);
640       return false;
641     }
642   }
643 
644   // For explicit properties, this is more involved.
645   ObjCPropertyDecl *prop = RefExpr->getExplicitProperty();
646   SetterSelector = prop->getSetterName();
647 
648   // Do a normal method lookup first.
649   if (ObjCMethodDecl *setter =
650         LookupMethodInReceiverType(S, SetterSelector, RefExpr)) {
651     if (setter->isPropertyAccessor() && warn)
652       if (const ObjCInterfaceDecl *IFace =
653           dyn_cast<ObjCInterfaceDecl>(setter->getDeclContext())) {
654         StringRef thisPropertyName = prop->getName();
655         // Try flipping the case of the first character.
656         char front = thisPropertyName.front();
657         front = isLowercase(front) ? toUppercase(front) : toLowercase(front);
658         SmallString<100> PropertyName = thisPropertyName;
659         PropertyName[0] = front;
660         IdentifierInfo *AltMember = &S.PP.getIdentifierTable().get(PropertyName);
661         if (ObjCPropertyDecl *prop1 = IFace->FindPropertyDeclaration(
662                 AltMember, prop->getQueryKind()))
663           if (prop != prop1 && (prop1->getSetterMethodDecl() == setter)) {
664             S.Diag(RefExpr->getExprLoc(), diag::error_property_setter_ambiguous_use)
665               << prop << prop1 << setter->getSelector();
666             S.Diag(prop->getLocation(), diag::note_property_declare);
667             S.Diag(prop1->getLocation(), diag::note_property_declare);
668           }
669       }
670     Setter = setter;
671     return true;
672   }
673 
674   // That can fail in the somewhat crazy situation that we're
675   // type-checking a message send within the @interface declaration
676   // that declared the @property.  But it's not clear that that's
677   // valuable to support.
678 
679   return false;
680 }
681 
DiagnoseUnsupportedPropertyUse()682 void ObjCPropertyOpBuilder::DiagnoseUnsupportedPropertyUse() {
683   if (S.getCurLexicalContext()->isObjCContainer() &&
684       S.getCurLexicalContext()->getDeclKind() != Decl::ObjCCategoryImpl &&
685       S.getCurLexicalContext()->getDeclKind() != Decl::ObjCImplementation) {
686     if (ObjCPropertyDecl *prop = RefExpr->getExplicitProperty()) {
687         S.Diag(RefExpr->getLocation(),
688                diag::err_property_function_in_objc_container);
689         S.Diag(prop->getLocation(), diag::note_property_declare);
690     }
691   }
692 }
693 
694 /// Capture the base object of an Objective-C property expression.
rebuildAndCaptureObject(Expr * syntacticBase)695 Expr *ObjCPropertyOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
696   assert(InstanceReceiver == nullptr);
697 
698   // If we have a base, capture it in an OVE and rebuild the syntactic
699   // form to use the OVE as its base.
700   if (RefExpr->isObjectReceiver()) {
701     InstanceReceiver = capture(RefExpr->getBase());
702     syntacticBase = Rebuilder(S, [=](Expr *, unsigned) -> Expr * {
703                       return InstanceReceiver;
704                     }).rebuild(syntacticBase);
705   }
706 
707   if (ObjCPropertyRefExpr *
708         refE = dyn_cast<ObjCPropertyRefExpr>(syntacticBase->IgnoreParens()))
709     SyntacticRefExpr = refE;
710 
711   return syntacticBase;
712 }
713 
714 /// Load from an Objective-C property reference.
buildGet()715 ExprResult ObjCPropertyOpBuilder::buildGet() {
716   findGetter();
717   if (!Getter) {
718     DiagnoseUnsupportedPropertyUse();
719     return ExprError();
720   }
721 
722   if (SyntacticRefExpr)
723     SyntacticRefExpr->setIsMessagingGetter();
724 
725   QualType receiverType = RefExpr->getReceiverType(S.Context);
726   if (!Getter->isImplicit())
727     S.DiagnoseUseOfDecl(Getter, GenericLoc, nullptr, true);
728   // Build a message-send.
729   ExprResult msg;
730   if ((Getter->isInstanceMethod() && !RefExpr->isClassReceiver()) ||
731       RefExpr->isObjectReceiver()) {
732     assert(InstanceReceiver || RefExpr->isSuperReceiver());
733     msg = S.BuildInstanceMessageImplicit(InstanceReceiver, receiverType,
734                                          GenericLoc, Getter->getSelector(),
735                                          Getter, None);
736   } else {
737     msg = S.BuildClassMessageImplicit(receiverType, RefExpr->isSuperReceiver(),
738                                       GenericLoc, Getter->getSelector(),
739                                       Getter, None);
740   }
741   return msg;
742 }
743 
744 /// Store to an Objective-C property reference.
745 ///
746 /// \param captureSetValueAsResult If true, capture the actual
747 ///   value being set as the value of the property operation.
buildSet(Expr * op,SourceLocation opcLoc,bool captureSetValueAsResult)748 ExprResult ObjCPropertyOpBuilder::buildSet(Expr *op, SourceLocation opcLoc,
749                                            bool captureSetValueAsResult) {
750   if (!findSetter(false)) {
751     DiagnoseUnsupportedPropertyUse();
752     return ExprError();
753   }
754 
755   if (SyntacticRefExpr)
756     SyntacticRefExpr->setIsMessagingSetter();
757 
758   QualType receiverType = RefExpr->getReceiverType(S.Context);
759 
760   // Use assignment constraints when possible; they give us better
761   // diagnostics.  "When possible" basically means anything except a
762   // C++ class type.
763   if (!S.getLangOpts().CPlusPlus || !op->getType()->isRecordType()) {
764     QualType paramType = (*Setter->param_begin())->getType()
765                            .substObjCMemberType(
766                              receiverType,
767                              Setter->getDeclContext(),
768                              ObjCSubstitutionContext::Parameter);
769     if (!S.getLangOpts().CPlusPlus || !paramType->isRecordType()) {
770       ExprResult opResult = op;
771       Sema::AssignConvertType assignResult
772         = S.CheckSingleAssignmentConstraints(paramType, opResult);
773       if (S.DiagnoseAssignmentResult(assignResult, opcLoc, paramType,
774                                      op->getType(), opResult.get(),
775                                      Sema::AA_Assigning))
776         return ExprError();
777 
778       op = opResult.get();
779       assert(op && "successful assignment left argument invalid?");
780     }
781   }
782 
783   // Arguments.
784   Expr *args[] = { op };
785 
786   // Build a message-send.
787   ExprResult msg;
788   if (!Setter->isImplicit())
789     S.DiagnoseUseOfDecl(Setter, GenericLoc, nullptr, true);
790   if ((Setter->isInstanceMethod() && !RefExpr->isClassReceiver()) ||
791       RefExpr->isObjectReceiver()) {
792     msg = S.BuildInstanceMessageImplicit(InstanceReceiver, receiverType,
793                                          GenericLoc, SetterSelector, Setter,
794                                          MultiExprArg(args, 1));
795   } else {
796     msg = S.BuildClassMessageImplicit(receiverType, RefExpr->isSuperReceiver(),
797                                       GenericLoc,
798                                       SetterSelector, Setter,
799                                       MultiExprArg(args, 1));
800   }
801 
802   if (!msg.isInvalid() && captureSetValueAsResult) {
803     ObjCMessageExpr *msgExpr =
804       cast<ObjCMessageExpr>(msg.get()->IgnoreImplicit());
805     Expr *arg = msgExpr->getArg(0);
806     if (CanCaptureValue(arg))
807       msgExpr->setArg(0, captureValueAsResult(arg));
808   }
809 
810   return msg;
811 }
812 
813 /// @property-specific behavior for doing lvalue-to-rvalue conversion.
buildRValueOperation(Expr * op)814 ExprResult ObjCPropertyOpBuilder::buildRValueOperation(Expr *op) {
815   // Explicit properties always have getters, but implicit ones don't.
816   // Check that before proceeding.
817   if (RefExpr->isImplicitProperty() && !RefExpr->getImplicitPropertyGetter()) {
818     S.Diag(RefExpr->getLocation(), diag::err_getter_not_found)
819         << RefExpr->getSourceRange();
820     return ExprError();
821   }
822 
823   ExprResult result = PseudoOpBuilder::buildRValueOperation(op);
824   if (result.isInvalid()) return ExprError();
825 
826   if (RefExpr->isExplicitProperty() && !Getter->hasRelatedResultType())
827     S.DiagnosePropertyAccessorMismatch(RefExpr->getExplicitProperty(),
828                                        Getter, RefExpr->getLocation());
829 
830   // As a special case, if the method returns 'id', try to get
831   // a better type from the property.
832   if (RefExpr->isExplicitProperty() && result.get()->isRValue()) {
833     QualType receiverType = RefExpr->getReceiverType(S.Context);
834     QualType propType = RefExpr->getExplicitProperty()
835                           ->getUsageType(receiverType);
836     if (result.get()->getType()->isObjCIdType()) {
837       if (const ObjCObjectPointerType *ptr
838             = propType->getAs<ObjCObjectPointerType>()) {
839         if (!ptr->isObjCIdType())
840           result = S.ImpCastExprToType(result.get(), propType, CK_BitCast);
841       }
842     }
843     if (S.getLangOpts().ObjCAutoRefCount) {
844       Qualifiers::ObjCLifetime LT = propType.getObjCLifetime();
845       if (LT == Qualifiers::OCL_Weak)
846         if (!S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, RefExpr->getLocation()))
847               S.getCurFunction()->markSafeWeakUse(RefExpr);
848     }
849   }
850 
851   return result;
852 }
853 
854 /// Try to build this as a call to a getter that returns a reference.
855 ///
856 /// \return true if it was possible, whether or not it actually
857 ///   succeeded
tryBuildGetOfReference(Expr * op,ExprResult & result)858 bool ObjCPropertyOpBuilder::tryBuildGetOfReference(Expr *op,
859                                                    ExprResult &result) {
860   if (!S.getLangOpts().CPlusPlus) return false;
861 
862   findGetter();
863   if (!Getter) {
864     // The property has no setter and no getter! This can happen if the type is
865     // invalid. Error have already been reported.
866     result = ExprError();
867     return true;
868   }
869 
870   // Only do this if the getter returns an l-value reference type.
871   QualType resultType = Getter->getReturnType();
872   if (!resultType->isLValueReferenceType()) return false;
873 
874   result = buildRValueOperation(op);
875   return true;
876 }
877 
878 /// @property-specific behavior for doing assignments.
879 ExprResult
buildAssignmentOperation(Scope * Sc,SourceLocation opcLoc,BinaryOperatorKind opcode,Expr * LHS,Expr * RHS)880 ObjCPropertyOpBuilder::buildAssignmentOperation(Scope *Sc,
881                                                 SourceLocation opcLoc,
882                                                 BinaryOperatorKind opcode,
883                                                 Expr *LHS, Expr *RHS) {
884   assert(BinaryOperator::isAssignmentOp(opcode));
885 
886   // If there's no setter, we have no choice but to try to assign to
887   // the result of the getter.
888   if (!findSetter()) {
889     ExprResult result;
890     if (tryBuildGetOfReference(LHS, result)) {
891       if (result.isInvalid()) return ExprError();
892       return S.BuildBinOp(Sc, opcLoc, opcode, result.get(), RHS);
893     }
894 
895     // Otherwise, it's an error.
896     S.Diag(opcLoc, diag::err_nosetter_property_assignment)
897       << unsigned(RefExpr->isImplicitProperty())
898       << SetterSelector
899       << LHS->getSourceRange() << RHS->getSourceRange();
900     return ExprError();
901   }
902 
903   // If there is a setter, we definitely want to use it.
904 
905   // Verify that we can do a compound assignment.
906   if (opcode != BO_Assign && !findGetter()) {
907     S.Diag(opcLoc, diag::err_nogetter_property_compound_assignment)
908       << LHS->getSourceRange() << RHS->getSourceRange();
909     return ExprError();
910   }
911 
912   ExprResult result =
913     PseudoOpBuilder::buildAssignmentOperation(Sc, opcLoc, opcode, LHS, RHS);
914   if (result.isInvalid()) return ExprError();
915 
916   // Various warnings about property assignments in ARC.
917   if (S.getLangOpts().ObjCAutoRefCount && InstanceReceiver) {
918     S.checkRetainCycles(InstanceReceiver->getSourceExpr(), RHS);
919     S.checkUnsafeExprAssigns(opcLoc, LHS, RHS);
920   }
921 
922   return result;
923 }
924 
925 /// @property-specific behavior for doing increments and decrements.
926 ExprResult
buildIncDecOperation(Scope * Sc,SourceLocation opcLoc,UnaryOperatorKind opcode,Expr * op)927 ObjCPropertyOpBuilder::buildIncDecOperation(Scope *Sc, SourceLocation opcLoc,
928                                             UnaryOperatorKind opcode,
929                                             Expr *op) {
930   // If there's no setter, we have no choice but to try to assign to
931   // the result of the getter.
932   if (!findSetter()) {
933     ExprResult result;
934     if (tryBuildGetOfReference(op, result)) {
935       if (result.isInvalid()) return ExprError();
936       return S.BuildUnaryOp(Sc, opcLoc, opcode, result.get());
937     }
938 
939     // Otherwise, it's an error.
940     S.Diag(opcLoc, diag::err_nosetter_property_incdec)
941       << unsigned(RefExpr->isImplicitProperty())
942       << unsigned(UnaryOperator::isDecrementOp(opcode))
943       << SetterSelector
944       << op->getSourceRange();
945     return ExprError();
946   }
947 
948   // If there is a setter, we definitely want to use it.
949 
950   // We also need a getter.
951   if (!findGetter()) {
952     assert(RefExpr->isImplicitProperty());
953     S.Diag(opcLoc, diag::err_nogetter_property_incdec)
954       << unsigned(UnaryOperator::isDecrementOp(opcode))
955       << GetterSelector
956       << op->getSourceRange();
957     return ExprError();
958   }
959 
960   return PseudoOpBuilder::buildIncDecOperation(Sc, opcLoc, opcode, op);
961 }
962 
complete(Expr * SyntacticForm)963 ExprResult ObjCPropertyOpBuilder::complete(Expr *SyntacticForm) {
964   if (S.getLangOpts().ObjCAutoRefCount && isWeakProperty() &&
965       !S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak,
966                          SyntacticForm->getLocStart()))
967       S.recordUseOfEvaluatedWeak(SyntacticRefExpr,
968                                  SyntacticRefExpr->isMessagingGetter());
969 
970   return PseudoOpBuilder::complete(SyntacticForm);
971 }
972 
973 // ObjCSubscript build stuff.
974 //
975 
976 /// objective-c subscripting-specific behavior for doing lvalue-to-rvalue
977 /// conversion.
978 /// FIXME. Remove this routine if it is proven that no additional
979 /// specifity is needed.
buildRValueOperation(Expr * op)980 ExprResult ObjCSubscriptOpBuilder::buildRValueOperation(Expr *op) {
981   ExprResult result = PseudoOpBuilder::buildRValueOperation(op);
982   if (result.isInvalid()) return ExprError();
983   return result;
984 }
985 
986 /// objective-c subscripting-specific  behavior for doing assignments.
987 ExprResult
buildAssignmentOperation(Scope * Sc,SourceLocation opcLoc,BinaryOperatorKind opcode,Expr * LHS,Expr * RHS)988 ObjCSubscriptOpBuilder::buildAssignmentOperation(Scope *Sc,
989                                                 SourceLocation opcLoc,
990                                                 BinaryOperatorKind opcode,
991                                                 Expr *LHS, Expr *RHS) {
992   assert(BinaryOperator::isAssignmentOp(opcode));
993   // There must be a method to do the Index'ed assignment.
994   if (!findAtIndexSetter())
995     return ExprError();
996 
997   // Verify that we can do a compound assignment.
998   if (opcode != BO_Assign && !findAtIndexGetter())
999     return ExprError();
1000 
1001   ExprResult result =
1002   PseudoOpBuilder::buildAssignmentOperation(Sc, opcLoc, opcode, LHS, RHS);
1003   if (result.isInvalid()) return ExprError();
1004 
1005   // Various warnings about objc Index'ed assignments in ARC.
1006   if (S.getLangOpts().ObjCAutoRefCount && InstanceBase) {
1007     S.checkRetainCycles(InstanceBase->getSourceExpr(), RHS);
1008     S.checkUnsafeExprAssigns(opcLoc, LHS, RHS);
1009   }
1010 
1011   return result;
1012 }
1013 
1014 /// Capture the base object of an Objective-C Index'ed expression.
rebuildAndCaptureObject(Expr * syntacticBase)1015 Expr *ObjCSubscriptOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
1016   assert(InstanceBase == nullptr);
1017 
1018   // Capture base expression in an OVE and rebuild the syntactic
1019   // form to use the OVE as its base expression.
1020   InstanceBase = capture(RefExpr->getBaseExpr());
1021   InstanceKey = capture(RefExpr->getKeyExpr());
1022 
1023   syntacticBase =
1024       Rebuilder(S, [=](Expr *, unsigned Idx) -> Expr * {
1025         switch (Idx) {
1026         case 0:
1027           return InstanceBase;
1028         case 1:
1029           return InstanceKey;
1030         default:
1031           llvm_unreachable("Unexpected index for ObjCSubscriptExpr");
1032         }
1033       }).rebuild(syntacticBase);
1034 
1035   return syntacticBase;
1036 }
1037 
1038 /// CheckSubscriptingKind - This routine decide what type
1039 /// of indexing represented by "FromE" is being done.
1040 Sema::ObjCSubscriptKind
CheckSubscriptingKind(Expr * FromE)1041   Sema::CheckSubscriptingKind(Expr *FromE) {
1042   // If the expression already has integral or enumeration type, we're golden.
1043   QualType T = FromE->getType();
1044   if (T->isIntegralOrEnumerationType())
1045     return OS_Array;
1046 
1047   // If we don't have a class type in C++, there's no way we can get an
1048   // expression of integral or enumeration type.
1049   const RecordType *RecordTy = T->getAs<RecordType>();
1050   if (!RecordTy &&
1051       (T->isObjCObjectPointerType() || T->isVoidPointerType()))
1052     // All other scalar cases are assumed to be dictionary indexing which
1053     // caller handles, with diagnostics if needed.
1054     return OS_Dictionary;
1055   if (!getLangOpts().CPlusPlus ||
1056       !RecordTy || RecordTy->isIncompleteType()) {
1057     // No indexing can be done. Issue diagnostics and quit.
1058     const Expr *IndexExpr = FromE->IgnoreParenImpCasts();
1059     if (isa<StringLiteral>(IndexExpr))
1060       Diag(FromE->getExprLoc(), diag::err_objc_subscript_pointer)
1061         << T << FixItHint::CreateInsertion(FromE->getExprLoc(), "@");
1062     else
1063       Diag(FromE->getExprLoc(), diag::err_objc_subscript_type_conversion)
1064         << T;
1065     return OS_Error;
1066   }
1067 
1068   // We must have a complete class type.
1069   if (RequireCompleteType(FromE->getExprLoc(), T,
1070                           diag::err_objc_index_incomplete_class_type, FromE))
1071     return OS_Error;
1072 
1073   // Look for a conversion to an integral, enumeration type, or
1074   // objective-C pointer type.
1075   int NoIntegrals=0, NoObjCIdPointers=0;
1076   SmallVector<CXXConversionDecl *, 4> ConversionDecls;
1077 
1078   for (NamedDecl *D : cast<CXXRecordDecl>(RecordTy->getDecl())
1079                           ->getVisibleConversionFunctions()) {
1080     if (CXXConversionDecl *Conversion =
1081             dyn_cast<CXXConversionDecl>(D->getUnderlyingDecl())) {
1082       QualType CT = Conversion->getConversionType().getNonReferenceType();
1083       if (CT->isIntegralOrEnumerationType()) {
1084         ++NoIntegrals;
1085         ConversionDecls.push_back(Conversion);
1086       }
1087       else if (CT->isObjCIdType() ||CT->isBlockPointerType()) {
1088         ++NoObjCIdPointers;
1089         ConversionDecls.push_back(Conversion);
1090       }
1091     }
1092   }
1093   if (NoIntegrals ==1 && NoObjCIdPointers == 0)
1094     return OS_Array;
1095   if (NoIntegrals == 0 && NoObjCIdPointers == 1)
1096     return OS_Dictionary;
1097   if (NoIntegrals == 0 && NoObjCIdPointers == 0) {
1098     // No conversion function was found. Issue diagnostic and return.
1099     Diag(FromE->getExprLoc(), diag::err_objc_subscript_type_conversion)
1100       << FromE->getType();
1101     return OS_Error;
1102   }
1103   Diag(FromE->getExprLoc(), diag::err_objc_multiple_subscript_type_conversion)
1104       << FromE->getType();
1105   for (unsigned int i = 0; i < ConversionDecls.size(); i++)
1106     Diag(ConversionDecls[i]->getLocation(), diag::not_conv_function_declared_at);
1107 
1108   return OS_Error;
1109 }
1110 
1111 /// CheckKeyForObjCARCConversion - This routine suggests bridge casting of CF
1112 /// objects used as dictionary subscript key objects.
CheckKeyForObjCARCConversion(Sema & S,QualType ContainerT,Expr * Key)1113 static void CheckKeyForObjCARCConversion(Sema &S, QualType ContainerT,
1114                                          Expr *Key) {
1115   if (ContainerT.isNull())
1116     return;
1117   // dictionary subscripting.
1118   // - (id)objectForKeyedSubscript:(id)key;
1119   IdentifierInfo *KeyIdents[] = {
1120     &S.Context.Idents.get("objectForKeyedSubscript")
1121   };
1122   Selector GetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
1123   ObjCMethodDecl *Getter = S.LookupMethodInObjectType(GetterSelector, ContainerT,
1124                                                       true /*instance*/);
1125   if (!Getter)
1126     return;
1127   QualType T = Getter->parameters()[0]->getType();
1128   S.CheckObjCARCConversion(Key->getSourceRange(),
1129                          T, Key, Sema::CCK_ImplicitConversion);
1130 }
1131 
findAtIndexGetter()1132 bool ObjCSubscriptOpBuilder::findAtIndexGetter() {
1133   if (AtIndexGetter)
1134     return true;
1135 
1136   Expr *BaseExpr = RefExpr->getBaseExpr();
1137   QualType BaseT = BaseExpr->getType();
1138 
1139   QualType ResultType;
1140   if (const ObjCObjectPointerType *PTy =
1141       BaseT->getAs<ObjCObjectPointerType>()) {
1142     ResultType = PTy->getPointeeType();
1143   }
1144   Sema::ObjCSubscriptKind Res =
1145     S.CheckSubscriptingKind(RefExpr->getKeyExpr());
1146   if (Res == Sema::OS_Error) {
1147     if (S.getLangOpts().ObjCAutoRefCount)
1148       CheckKeyForObjCARCConversion(S, ResultType,
1149                                    RefExpr->getKeyExpr());
1150     return false;
1151   }
1152   bool arrayRef = (Res == Sema::OS_Array);
1153 
1154   if (ResultType.isNull()) {
1155     S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_base_type)
1156       << BaseExpr->getType() << arrayRef;
1157     return false;
1158   }
1159   if (!arrayRef) {
1160     // dictionary subscripting.
1161     // - (id)objectForKeyedSubscript:(id)key;
1162     IdentifierInfo *KeyIdents[] = {
1163       &S.Context.Idents.get("objectForKeyedSubscript")
1164     };
1165     AtIndexGetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
1166   }
1167   else {
1168     // - (id)objectAtIndexedSubscript:(size_t)index;
1169     IdentifierInfo *KeyIdents[] = {
1170       &S.Context.Idents.get("objectAtIndexedSubscript")
1171     };
1172 
1173     AtIndexGetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
1174   }
1175 
1176   AtIndexGetter = S.LookupMethodInObjectType(AtIndexGetterSelector, ResultType,
1177                                              true /*instance*/);
1178   bool receiverIdType = (BaseT->isObjCIdType() ||
1179                          BaseT->isObjCQualifiedIdType());
1180 
1181   if (!AtIndexGetter && S.getLangOpts().DebuggerObjCLiteral) {
1182     AtIndexGetter = ObjCMethodDecl::Create(S.Context, SourceLocation(),
1183                            SourceLocation(), AtIndexGetterSelector,
1184                            S.Context.getObjCIdType() /*ReturnType*/,
1185                            nullptr /*TypeSourceInfo */,
1186                            S.Context.getTranslationUnitDecl(),
1187                            true /*Instance*/, false/*isVariadic*/,
1188                            /*isPropertyAccessor=*/false,
1189                            /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
1190                            ObjCMethodDecl::Required,
1191                            false);
1192     ParmVarDecl *Argument = ParmVarDecl::Create(S.Context, AtIndexGetter,
1193                                                 SourceLocation(), SourceLocation(),
1194                                                 arrayRef ? &S.Context.Idents.get("index")
1195                                                          : &S.Context.Idents.get("key"),
1196                                                 arrayRef ? S.Context.UnsignedLongTy
1197                                                          : S.Context.getObjCIdType(),
1198                                                 /*TInfo=*/nullptr,
1199                                                 SC_None,
1200                                                 nullptr);
1201     AtIndexGetter->setMethodParams(S.Context, Argument, None);
1202   }
1203 
1204   if (!AtIndexGetter) {
1205     if (!receiverIdType) {
1206       S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_method_not_found)
1207       << BaseExpr->getType() << 0 << arrayRef;
1208       return false;
1209     }
1210     AtIndexGetter =
1211       S.LookupInstanceMethodInGlobalPool(AtIndexGetterSelector,
1212                                          RefExpr->getSourceRange(),
1213                                          true);
1214   }
1215 
1216   if (AtIndexGetter) {
1217     QualType T = AtIndexGetter->parameters()[0]->getType();
1218     if ((arrayRef && !T->isIntegralOrEnumerationType()) ||
1219         (!arrayRef && !T->isObjCObjectPointerType())) {
1220       S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1221              arrayRef ? diag::err_objc_subscript_index_type
1222                       : diag::err_objc_subscript_key_type) << T;
1223       S.Diag(AtIndexGetter->parameters()[0]->getLocation(),
1224              diag::note_parameter_type) << T;
1225       return false;
1226     }
1227     QualType R = AtIndexGetter->getReturnType();
1228     if (!R->isObjCObjectPointerType()) {
1229       S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1230              diag::err_objc_indexing_method_result_type) << R << arrayRef;
1231       S.Diag(AtIndexGetter->getLocation(), diag::note_method_declared_at) <<
1232         AtIndexGetter->getDeclName();
1233     }
1234   }
1235   return true;
1236 }
1237 
findAtIndexSetter()1238 bool ObjCSubscriptOpBuilder::findAtIndexSetter() {
1239   if (AtIndexSetter)
1240     return true;
1241 
1242   Expr *BaseExpr = RefExpr->getBaseExpr();
1243   QualType BaseT = BaseExpr->getType();
1244 
1245   QualType ResultType;
1246   if (const ObjCObjectPointerType *PTy =
1247       BaseT->getAs<ObjCObjectPointerType>()) {
1248     ResultType = PTy->getPointeeType();
1249   }
1250 
1251   Sema::ObjCSubscriptKind Res =
1252     S.CheckSubscriptingKind(RefExpr->getKeyExpr());
1253   if (Res == Sema::OS_Error) {
1254     if (S.getLangOpts().ObjCAutoRefCount)
1255       CheckKeyForObjCARCConversion(S, ResultType,
1256                                    RefExpr->getKeyExpr());
1257     return false;
1258   }
1259   bool arrayRef = (Res == Sema::OS_Array);
1260 
1261   if (ResultType.isNull()) {
1262     S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_base_type)
1263       << BaseExpr->getType() << arrayRef;
1264     return false;
1265   }
1266 
1267   if (!arrayRef) {
1268     // dictionary subscripting.
1269     // - (void)setObject:(id)object forKeyedSubscript:(id)key;
1270     IdentifierInfo *KeyIdents[] = {
1271       &S.Context.Idents.get("setObject"),
1272       &S.Context.Idents.get("forKeyedSubscript")
1273     };
1274     AtIndexSetterSelector = S.Context.Selectors.getSelector(2, KeyIdents);
1275   }
1276   else {
1277     // - (void)setObject:(id)object atIndexedSubscript:(NSInteger)index;
1278     IdentifierInfo *KeyIdents[] = {
1279       &S.Context.Idents.get("setObject"),
1280       &S.Context.Idents.get("atIndexedSubscript")
1281     };
1282     AtIndexSetterSelector = S.Context.Selectors.getSelector(2, KeyIdents);
1283   }
1284   AtIndexSetter = S.LookupMethodInObjectType(AtIndexSetterSelector, ResultType,
1285                                              true /*instance*/);
1286 
1287   bool receiverIdType = (BaseT->isObjCIdType() ||
1288                          BaseT->isObjCQualifiedIdType());
1289 
1290   if (!AtIndexSetter && S.getLangOpts().DebuggerObjCLiteral) {
1291     TypeSourceInfo *ReturnTInfo = nullptr;
1292     QualType ReturnType = S.Context.VoidTy;
1293     AtIndexSetter = ObjCMethodDecl::Create(
1294         S.Context, SourceLocation(), SourceLocation(), AtIndexSetterSelector,
1295         ReturnType, ReturnTInfo, S.Context.getTranslationUnitDecl(),
1296         true /*Instance*/, false /*isVariadic*/,
1297         /*isPropertyAccessor=*/false,
1298         /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
1299         ObjCMethodDecl::Required, false);
1300     SmallVector<ParmVarDecl *, 2> Params;
1301     ParmVarDecl *object = ParmVarDecl::Create(S.Context, AtIndexSetter,
1302                                                 SourceLocation(), SourceLocation(),
1303                                                 &S.Context.Idents.get("object"),
1304                                                 S.Context.getObjCIdType(),
1305                                                 /*TInfo=*/nullptr,
1306                                                 SC_None,
1307                                                 nullptr);
1308     Params.push_back(object);
1309     ParmVarDecl *key = ParmVarDecl::Create(S.Context, AtIndexSetter,
1310                                                 SourceLocation(), SourceLocation(),
1311                                                 arrayRef ?  &S.Context.Idents.get("index")
1312                                                          :  &S.Context.Idents.get("key"),
1313                                                 arrayRef ? S.Context.UnsignedLongTy
1314                                                          : S.Context.getObjCIdType(),
1315                                                 /*TInfo=*/nullptr,
1316                                                 SC_None,
1317                                                 nullptr);
1318     Params.push_back(key);
1319     AtIndexSetter->setMethodParams(S.Context, Params, None);
1320   }
1321 
1322   if (!AtIndexSetter) {
1323     if (!receiverIdType) {
1324       S.Diag(BaseExpr->getExprLoc(),
1325              diag::err_objc_subscript_method_not_found)
1326       << BaseExpr->getType() << 1 << arrayRef;
1327       return false;
1328     }
1329     AtIndexSetter =
1330       S.LookupInstanceMethodInGlobalPool(AtIndexSetterSelector,
1331                                          RefExpr->getSourceRange(),
1332                                          true);
1333   }
1334 
1335   bool err = false;
1336   if (AtIndexSetter && arrayRef) {
1337     QualType T = AtIndexSetter->parameters()[1]->getType();
1338     if (!T->isIntegralOrEnumerationType()) {
1339       S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1340              diag::err_objc_subscript_index_type) << T;
1341       S.Diag(AtIndexSetter->parameters()[1]->getLocation(),
1342              diag::note_parameter_type) << T;
1343       err = true;
1344     }
1345     T = AtIndexSetter->parameters()[0]->getType();
1346     if (!T->isObjCObjectPointerType()) {
1347       S.Diag(RefExpr->getBaseExpr()->getExprLoc(),
1348              diag::err_objc_subscript_object_type) << T << arrayRef;
1349       S.Diag(AtIndexSetter->parameters()[0]->getLocation(),
1350              diag::note_parameter_type) << T;
1351       err = true;
1352     }
1353   }
1354   else if (AtIndexSetter && !arrayRef)
1355     for (unsigned i=0; i <2; i++) {
1356       QualType T = AtIndexSetter->parameters()[i]->getType();
1357       if (!T->isObjCObjectPointerType()) {
1358         if (i == 1)
1359           S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1360                  diag::err_objc_subscript_key_type) << T;
1361         else
1362           S.Diag(RefExpr->getBaseExpr()->getExprLoc(),
1363                  diag::err_objc_subscript_dic_object_type) << T;
1364         S.Diag(AtIndexSetter->parameters()[i]->getLocation(),
1365                diag::note_parameter_type) << T;
1366         err = true;
1367       }
1368     }
1369 
1370   return !err;
1371 }
1372 
1373 // Get the object at "Index" position in the container.
1374 // [BaseExpr objectAtIndexedSubscript : IndexExpr];
buildGet()1375 ExprResult ObjCSubscriptOpBuilder::buildGet() {
1376   if (!findAtIndexGetter())
1377     return ExprError();
1378 
1379   QualType receiverType = InstanceBase->getType();
1380 
1381   // Build a message-send.
1382   ExprResult msg;
1383   Expr *Index = InstanceKey;
1384 
1385   // Arguments.
1386   Expr *args[] = { Index };
1387   assert(InstanceBase);
1388   if (AtIndexGetter)
1389     S.DiagnoseUseOfDecl(AtIndexGetter, GenericLoc);
1390   msg = S.BuildInstanceMessageImplicit(InstanceBase, receiverType,
1391                                        GenericLoc,
1392                                        AtIndexGetterSelector, AtIndexGetter,
1393                                        MultiExprArg(args, 1));
1394   return msg;
1395 }
1396 
1397 /// Store into the container the "op" object at "Index"'ed location
1398 /// by building this messaging expression:
1399 /// - (void)setObject:(id)object atIndexedSubscript:(NSInteger)index;
1400 /// \param captureSetValueAsResult If true, capture the actual
1401 ///   value being set as the value of the property operation.
buildSet(Expr * op,SourceLocation opcLoc,bool captureSetValueAsResult)1402 ExprResult ObjCSubscriptOpBuilder::buildSet(Expr *op, SourceLocation opcLoc,
1403                                            bool captureSetValueAsResult) {
1404   if (!findAtIndexSetter())
1405     return ExprError();
1406   if (AtIndexSetter)
1407     S.DiagnoseUseOfDecl(AtIndexSetter, GenericLoc);
1408   QualType receiverType = InstanceBase->getType();
1409   Expr *Index = InstanceKey;
1410 
1411   // Arguments.
1412   Expr *args[] = { op, Index };
1413 
1414   // Build a message-send.
1415   ExprResult msg = S.BuildInstanceMessageImplicit(InstanceBase, receiverType,
1416                                                   GenericLoc,
1417                                                   AtIndexSetterSelector,
1418                                                   AtIndexSetter,
1419                                                   MultiExprArg(args, 2));
1420 
1421   if (!msg.isInvalid() && captureSetValueAsResult) {
1422     ObjCMessageExpr *msgExpr =
1423       cast<ObjCMessageExpr>(msg.get()->IgnoreImplicit());
1424     Expr *arg = msgExpr->getArg(0);
1425     if (CanCaptureValue(arg))
1426       msgExpr->setArg(0, captureValueAsResult(arg));
1427   }
1428 
1429   return msg;
1430 }
1431 
1432 //===----------------------------------------------------------------------===//
1433 //  MSVC __declspec(property) references
1434 //===----------------------------------------------------------------------===//
1435 
1436 MSPropertyRefExpr *
getBaseMSProperty(MSPropertySubscriptExpr * E)1437 MSPropertyOpBuilder::getBaseMSProperty(MSPropertySubscriptExpr *E) {
1438   CallArgs.insert(CallArgs.begin(), E->getIdx());
1439   Expr *Base = E->getBase()->IgnoreParens();
1440   while (auto *MSPropSubscript = dyn_cast<MSPropertySubscriptExpr>(Base)) {
1441     CallArgs.insert(CallArgs.begin(), MSPropSubscript->getIdx());
1442     Base = MSPropSubscript->getBase()->IgnoreParens();
1443   }
1444   return cast<MSPropertyRefExpr>(Base);
1445 }
1446 
rebuildAndCaptureObject(Expr * syntacticBase)1447 Expr *MSPropertyOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
1448   InstanceBase = capture(RefExpr->getBaseExpr());
1449   std::for_each(CallArgs.begin(), CallArgs.end(),
1450                 [this](Expr *&Arg) { Arg = capture(Arg); });
1451   syntacticBase = Rebuilder(S, [=](Expr *, unsigned Idx) -> Expr * {
1452                     switch (Idx) {
1453                     case 0:
1454                       return InstanceBase;
1455                     default:
1456                       assert(Idx <= CallArgs.size());
1457                       return CallArgs[Idx - 1];
1458                     }
1459                   }).rebuild(syntacticBase);
1460 
1461   return syntacticBase;
1462 }
1463 
buildGet()1464 ExprResult MSPropertyOpBuilder::buildGet() {
1465   if (!RefExpr->getPropertyDecl()->hasGetter()) {
1466     S.Diag(RefExpr->getMemberLoc(), diag::err_no_accessor_for_property)
1467       << 0 /* getter */ << RefExpr->getPropertyDecl();
1468     return ExprError();
1469   }
1470 
1471   UnqualifiedId GetterName;
1472   IdentifierInfo *II = RefExpr->getPropertyDecl()->getGetterId();
1473   GetterName.setIdentifier(II, RefExpr->getMemberLoc());
1474   CXXScopeSpec SS;
1475   SS.Adopt(RefExpr->getQualifierLoc());
1476   ExprResult GetterExpr =
1477       S.ActOnMemberAccessExpr(S.getCurScope(), InstanceBase, SourceLocation(),
1478                               RefExpr->isArrow() ? tok::arrow : tok::period, SS,
1479                               SourceLocation(), GetterName, nullptr);
1480   if (GetterExpr.isInvalid()) {
1481     S.Diag(RefExpr->getMemberLoc(),
1482            diag::error_cannot_find_suitable_accessor) << 0 /* getter */
1483       << RefExpr->getPropertyDecl();
1484     return ExprError();
1485   }
1486 
1487   return S.ActOnCallExpr(S.getCurScope(), GetterExpr.get(),
1488                          RefExpr->getSourceRange().getBegin(), CallArgs,
1489                          RefExpr->getSourceRange().getEnd());
1490 }
1491 
buildSet(Expr * op,SourceLocation sl,bool captureSetValueAsResult)1492 ExprResult MSPropertyOpBuilder::buildSet(Expr *op, SourceLocation sl,
1493                                          bool captureSetValueAsResult) {
1494   if (!RefExpr->getPropertyDecl()->hasSetter()) {
1495     S.Diag(RefExpr->getMemberLoc(), diag::err_no_accessor_for_property)
1496       << 1 /* setter */ << RefExpr->getPropertyDecl();
1497     return ExprError();
1498   }
1499 
1500   UnqualifiedId SetterName;
1501   IdentifierInfo *II = RefExpr->getPropertyDecl()->getSetterId();
1502   SetterName.setIdentifier(II, RefExpr->getMemberLoc());
1503   CXXScopeSpec SS;
1504   SS.Adopt(RefExpr->getQualifierLoc());
1505   ExprResult SetterExpr =
1506       S.ActOnMemberAccessExpr(S.getCurScope(), InstanceBase, SourceLocation(),
1507                               RefExpr->isArrow() ? tok::arrow : tok::period, SS,
1508                               SourceLocation(), SetterName, nullptr);
1509   if (SetterExpr.isInvalid()) {
1510     S.Diag(RefExpr->getMemberLoc(),
1511            diag::error_cannot_find_suitable_accessor) << 1 /* setter */
1512       << RefExpr->getPropertyDecl();
1513     return ExprError();
1514   }
1515 
1516   SmallVector<Expr*, 4> ArgExprs;
1517   ArgExprs.append(CallArgs.begin(), CallArgs.end());
1518   ArgExprs.push_back(op);
1519   return S.ActOnCallExpr(S.getCurScope(), SetterExpr.get(),
1520                          RefExpr->getSourceRange().getBegin(), ArgExprs,
1521                          op->getSourceRange().getEnd());
1522 }
1523 
1524 //===----------------------------------------------------------------------===//
1525 //  General Sema routines.
1526 //===----------------------------------------------------------------------===//
1527 
checkPseudoObjectRValue(Expr * E)1528 ExprResult Sema::checkPseudoObjectRValue(Expr *E) {
1529   Expr *opaqueRef = E->IgnoreParens();
1530   if (ObjCPropertyRefExpr *refExpr
1531         = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1532     ObjCPropertyOpBuilder builder(*this, refExpr);
1533     return builder.buildRValueOperation(E);
1534   }
1535   else if (ObjCSubscriptRefExpr *refExpr
1536            = dyn_cast<ObjCSubscriptRefExpr>(opaqueRef)) {
1537     ObjCSubscriptOpBuilder builder(*this, refExpr);
1538     return builder.buildRValueOperation(E);
1539   } else if (MSPropertyRefExpr *refExpr
1540              = dyn_cast<MSPropertyRefExpr>(opaqueRef)) {
1541     MSPropertyOpBuilder builder(*this, refExpr);
1542     return builder.buildRValueOperation(E);
1543   } else if (MSPropertySubscriptExpr *RefExpr =
1544                  dyn_cast<MSPropertySubscriptExpr>(opaqueRef)) {
1545     MSPropertyOpBuilder Builder(*this, RefExpr);
1546     return Builder.buildRValueOperation(E);
1547   } else {
1548     llvm_unreachable("unknown pseudo-object kind!");
1549   }
1550 }
1551 
1552 /// Check an increment or decrement of a pseudo-object expression.
checkPseudoObjectIncDec(Scope * Sc,SourceLocation opcLoc,UnaryOperatorKind opcode,Expr * op)1553 ExprResult Sema::checkPseudoObjectIncDec(Scope *Sc, SourceLocation opcLoc,
1554                                          UnaryOperatorKind opcode, Expr *op) {
1555   // Do nothing if the operand is dependent.
1556   if (op->isTypeDependent())
1557     return new (Context) UnaryOperator(op, opcode, Context.DependentTy,
1558                                        VK_RValue, OK_Ordinary, opcLoc);
1559 
1560   assert(UnaryOperator::isIncrementDecrementOp(opcode));
1561   Expr *opaqueRef = op->IgnoreParens();
1562   if (ObjCPropertyRefExpr *refExpr
1563         = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1564     ObjCPropertyOpBuilder builder(*this, refExpr);
1565     return builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1566   } else if (isa<ObjCSubscriptRefExpr>(opaqueRef)) {
1567     Diag(opcLoc, diag::err_illegal_container_subscripting_op);
1568     return ExprError();
1569   } else if (MSPropertyRefExpr *refExpr
1570              = dyn_cast<MSPropertyRefExpr>(opaqueRef)) {
1571     MSPropertyOpBuilder builder(*this, refExpr);
1572     return builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1573   } else if (MSPropertySubscriptExpr *RefExpr
1574              = dyn_cast<MSPropertySubscriptExpr>(opaqueRef)) {
1575     MSPropertyOpBuilder Builder(*this, RefExpr);
1576     return Builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1577   } else {
1578     llvm_unreachable("unknown pseudo-object kind!");
1579   }
1580 }
1581 
checkPseudoObjectAssignment(Scope * S,SourceLocation opcLoc,BinaryOperatorKind opcode,Expr * LHS,Expr * RHS)1582 ExprResult Sema::checkPseudoObjectAssignment(Scope *S, SourceLocation opcLoc,
1583                                              BinaryOperatorKind opcode,
1584                                              Expr *LHS, Expr *RHS) {
1585   // Do nothing if either argument is dependent.
1586   if (LHS->isTypeDependent() || RHS->isTypeDependent())
1587     return new (Context) BinaryOperator(LHS, RHS, opcode, Context.DependentTy,
1588                                         VK_RValue, OK_Ordinary, opcLoc, false);
1589 
1590   // Filter out non-overload placeholder types in the RHS.
1591   if (RHS->getType()->isNonOverloadPlaceholderType()) {
1592     ExprResult result = CheckPlaceholderExpr(RHS);
1593     if (result.isInvalid()) return ExprError();
1594     RHS = result.get();
1595   }
1596 
1597   Expr *opaqueRef = LHS->IgnoreParens();
1598   if (ObjCPropertyRefExpr *refExpr
1599         = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1600     ObjCPropertyOpBuilder builder(*this, refExpr);
1601     return builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1602   } else if (ObjCSubscriptRefExpr *refExpr
1603              = dyn_cast<ObjCSubscriptRefExpr>(opaqueRef)) {
1604     ObjCSubscriptOpBuilder builder(*this, refExpr);
1605     return builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1606   } else if (MSPropertyRefExpr *refExpr
1607              = dyn_cast<MSPropertyRefExpr>(opaqueRef)) {
1608       MSPropertyOpBuilder builder(*this, refExpr);
1609       return builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1610   } else if (MSPropertySubscriptExpr *RefExpr
1611              = dyn_cast<MSPropertySubscriptExpr>(opaqueRef)) {
1612       MSPropertyOpBuilder Builder(*this, RefExpr);
1613       return Builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1614   } else {
1615     llvm_unreachable("unknown pseudo-object kind!");
1616   }
1617 }
1618 
1619 /// Given a pseudo-object reference, rebuild it without the opaque
1620 /// values.  Basically, undo the behavior of rebuildAndCaptureObject.
1621 /// This should never operate in-place.
stripOpaqueValuesFromPseudoObjectRef(Sema & S,Expr * E)1622 static Expr *stripOpaqueValuesFromPseudoObjectRef(Sema &S, Expr *E) {
1623   return Rebuilder(S,
1624                    [=](Expr *E, unsigned) -> Expr * {
1625                      return cast<OpaqueValueExpr>(E)->getSourceExpr();
1626                    })
1627       .rebuild(E);
1628 }
1629 
1630 /// Given a pseudo-object expression, recreate what it looks like
1631 /// syntactically without the attendant OpaqueValueExprs.
1632 ///
1633 /// This is a hack which should be removed when TreeTransform is
1634 /// capable of rebuilding a tree without stripping implicit
1635 /// operations.
recreateSyntacticForm(PseudoObjectExpr * E)1636 Expr *Sema::recreateSyntacticForm(PseudoObjectExpr *E) {
1637   Expr *syntax = E->getSyntacticForm();
1638   if (UnaryOperator *uop = dyn_cast<UnaryOperator>(syntax)) {
1639     Expr *op = stripOpaqueValuesFromPseudoObjectRef(*this, uop->getSubExpr());
1640     return new (Context) UnaryOperator(op, uop->getOpcode(), uop->getType(),
1641                                        uop->getValueKind(), uop->getObjectKind(),
1642                                        uop->getOperatorLoc());
1643   } else if (CompoundAssignOperator *cop
1644                = dyn_cast<CompoundAssignOperator>(syntax)) {
1645     Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, cop->getLHS());
1646     Expr *rhs = cast<OpaqueValueExpr>(cop->getRHS())->getSourceExpr();
1647     return new (Context) CompoundAssignOperator(lhs, rhs, cop->getOpcode(),
1648                                                 cop->getType(),
1649                                                 cop->getValueKind(),
1650                                                 cop->getObjectKind(),
1651                                                 cop->getComputationLHSType(),
1652                                                 cop->getComputationResultType(),
1653                                                 cop->getOperatorLoc(), false);
1654   } else if (BinaryOperator *bop = dyn_cast<BinaryOperator>(syntax)) {
1655     Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, bop->getLHS());
1656     Expr *rhs = cast<OpaqueValueExpr>(bop->getRHS())->getSourceExpr();
1657     return new (Context) BinaryOperator(lhs, rhs, bop->getOpcode(),
1658                                         bop->getType(), bop->getValueKind(),
1659                                         bop->getObjectKind(),
1660                                         bop->getOperatorLoc(), false);
1661   } else {
1662     assert(syntax->hasPlaceholderType(BuiltinType::PseudoObject));
1663     return stripOpaqueValuesFromPseudoObjectRef(*this, syntax);
1664   }
1665 }
1666