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
42using namespace clang;
43using namespace sema;
44
45namespace {
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;
52    Rebuilder(Sema &S, const SpecificRebuilderRefTy &SpecificCallback)
53        : S(S), MSPropertySubscriptCount(0),
54          SpecificCallback(SpecificCallback) {}
55
56    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    }
74    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    }
85    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    }
94    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
107    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
194    PseudoOpBuilder(Sema &S, SourceLocation genericLoc)
195      : S(S), ResultIndex(PseudoObjectExpr::NoResult),
196        GenericLoc(genericLoc) {}
197
198    virtual ~PseudoOpBuilder() {}
199
200    /// Add a normal semantic expression.
201    void addSemanticExpr(Expr *semantic) {
202      Semantics.push_back(semantic);
203    }
204
205    /// Add the 'result' semantic expression.
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
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.
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.
261    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:
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:
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:
344   MSPropertyOpBuilder(Sema &S, MSPropertyRefExpr *refExpr) :
345     PseudoOpBuilder(S, refExpr->getSourceRange().getBegin()),
346     RefExpr(refExpr), InstanceBase(nullptr) {}
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;
356   bool captureSetValueAsResult() const override { return false; }
357 };
358}
359
360/// Capture the given expression in an OpaqueValueExpr.
361OpaqueValueExpr *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
379OpaqueValueExpr *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.
403ExprResult 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.
409ExprResult 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.
421ExprResult
422PseudoOpBuilder::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.
485ExprResult
486PseudoOpBuilder::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.
542static 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
576bool 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 !Prop->hasAttr<IBOutletAttr>();
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
593bool 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
625bool 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(AltMember))
662          if (prop != prop1 && (prop1->getSetterMethodDecl() == setter)) {
663            S.Diag(RefExpr->getExprLoc(), diag::error_property_setter_ambiguous_use)
664              << prop << prop1 << setter->getSelector();
665            S.Diag(prop->getLocation(), diag::note_property_declare);
666            S.Diag(prop1->getLocation(), diag::note_property_declare);
667          }
668      }
669    Setter = setter;
670    return true;
671  }
672
673  // That can fail in the somewhat crazy situation that we're
674  // type-checking a message send within the @interface declaration
675  // that declared the @property.  But it's not clear that that's
676  // valuable to support.
677
678  return false;
679}
680
681void ObjCPropertyOpBuilder::DiagnoseUnsupportedPropertyUse() {
682  if (S.getCurLexicalContext()->isObjCContainer() &&
683      S.getCurLexicalContext()->getDeclKind() != Decl::ObjCCategoryImpl &&
684      S.getCurLexicalContext()->getDeclKind() != Decl::ObjCImplementation) {
685    if (ObjCPropertyDecl *prop = RefExpr->getExplicitProperty()) {
686        S.Diag(RefExpr->getLocation(),
687               diag::err_property_function_in_objc_container);
688        S.Diag(prop->getLocation(), diag::note_property_declare);
689    }
690  }
691}
692
693/// Capture the base object of an Objective-C property expression.
694Expr *ObjCPropertyOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
695  assert(InstanceReceiver == nullptr);
696
697  // If we have a base, capture it in an OVE and rebuild the syntactic
698  // form to use the OVE as its base.
699  if (RefExpr->isObjectReceiver()) {
700    InstanceReceiver = capture(RefExpr->getBase());
701    syntacticBase = Rebuilder(S, [=](Expr *, unsigned) -> Expr * {
702                      return InstanceReceiver;
703                    }).rebuild(syntacticBase);
704  }
705
706  if (ObjCPropertyRefExpr *
707        refE = dyn_cast<ObjCPropertyRefExpr>(syntacticBase->IgnoreParens()))
708    SyntacticRefExpr = refE;
709
710  return syntacticBase;
711}
712
713/// Load from an Objective-C property reference.
714ExprResult ObjCPropertyOpBuilder::buildGet() {
715  findGetter();
716  if (!Getter) {
717    DiagnoseUnsupportedPropertyUse();
718    return ExprError();
719  }
720
721  if (SyntacticRefExpr)
722    SyntacticRefExpr->setIsMessagingGetter();
723
724  QualType receiverType = RefExpr->getReceiverType(S.Context);
725  if (!Getter->isImplicit())
726    S.DiagnoseUseOfDecl(Getter, GenericLoc, nullptr, true);
727  // Build a message-send.
728  ExprResult msg;
729  if ((Getter->isInstanceMethod() && !RefExpr->isClassReceiver()) ||
730      RefExpr->isObjectReceiver()) {
731    assert(InstanceReceiver || RefExpr->isSuperReceiver());
732    msg = S.BuildInstanceMessageImplicit(InstanceReceiver, receiverType,
733                                         GenericLoc, Getter->getSelector(),
734                                         Getter, None);
735  } else {
736    msg = S.BuildClassMessageImplicit(receiverType, RefExpr->isSuperReceiver(),
737                                      GenericLoc, Getter->getSelector(),
738                                      Getter, None);
739  }
740  return msg;
741}
742
743/// Store to an Objective-C property reference.
744///
745/// \param captureSetValueAsResult If true, capture the actual
746///   value being set as the value of the property operation.
747ExprResult ObjCPropertyOpBuilder::buildSet(Expr *op, SourceLocation opcLoc,
748                                           bool captureSetValueAsResult) {
749  if (!findSetter(false)) {
750    DiagnoseUnsupportedPropertyUse();
751    return ExprError();
752  }
753
754  if (SyntacticRefExpr)
755    SyntacticRefExpr->setIsMessagingSetter();
756
757  QualType receiverType = RefExpr->getReceiverType(S.Context);
758
759  // Use assignment constraints when possible; they give us better
760  // diagnostics.  "When possible" basically means anything except a
761  // C++ class type.
762  if (!S.getLangOpts().CPlusPlus || !op->getType()->isRecordType()) {
763    QualType paramType = (*Setter->param_begin())->getType()
764                           .substObjCMemberType(
765                             receiverType,
766                             Setter->getDeclContext(),
767                             ObjCSubstitutionContext::Parameter);
768    if (!S.getLangOpts().CPlusPlus || !paramType->isRecordType()) {
769      ExprResult opResult = op;
770      Sema::AssignConvertType assignResult
771        = S.CheckSingleAssignmentConstraints(paramType, opResult);
772      if (S.DiagnoseAssignmentResult(assignResult, opcLoc, paramType,
773                                     op->getType(), opResult.get(),
774                                     Sema::AA_Assigning))
775        return ExprError();
776
777      op = opResult.get();
778      assert(op && "successful assignment left argument invalid?");
779    }
780  }
781
782  // Arguments.
783  Expr *args[] = { op };
784
785  // Build a message-send.
786  ExprResult msg;
787  if (!Setter->isImplicit())
788    S.DiagnoseUseOfDecl(Setter, GenericLoc, nullptr, true);
789  if ((Setter->isInstanceMethod() && !RefExpr->isClassReceiver()) ||
790      RefExpr->isObjectReceiver()) {
791    msg = S.BuildInstanceMessageImplicit(InstanceReceiver, receiverType,
792                                         GenericLoc, SetterSelector, Setter,
793                                         MultiExprArg(args, 1));
794  } else {
795    msg = S.BuildClassMessageImplicit(receiverType, RefExpr->isSuperReceiver(),
796                                      GenericLoc,
797                                      SetterSelector, Setter,
798                                      MultiExprArg(args, 1));
799  }
800
801  if (!msg.isInvalid() && captureSetValueAsResult) {
802    ObjCMessageExpr *msgExpr =
803      cast<ObjCMessageExpr>(msg.get()->IgnoreImplicit());
804    Expr *arg = msgExpr->getArg(0);
805    if (CanCaptureValue(arg))
806      msgExpr->setArg(0, captureValueAsResult(arg));
807  }
808
809  return msg;
810}
811
812/// @property-specific behavior for doing lvalue-to-rvalue conversion.
813ExprResult ObjCPropertyOpBuilder::buildRValueOperation(Expr *op) {
814  // Explicit properties always have getters, but implicit ones don't.
815  // Check that before proceeding.
816  if (RefExpr->isImplicitProperty() && !RefExpr->getImplicitPropertyGetter()) {
817    S.Diag(RefExpr->getLocation(), diag::err_getter_not_found)
818        << RefExpr->getSourceRange();
819    return ExprError();
820  }
821
822  ExprResult result = PseudoOpBuilder::buildRValueOperation(op);
823  if (result.isInvalid()) return ExprError();
824
825  if (RefExpr->isExplicitProperty() && !Getter->hasRelatedResultType())
826    S.DiagnosePropertyAccessorMismatch(RefExpr->getExplicitProperty(),
827                                       Getter, RefExpr->getLocation());
828
829  // As a special case, if the method returns 'id', try to get
830  // a better type from the property.
831  if (RefExpr->isExplicitProperty() && result.get()->isRValue()) {
832    QualType receiverType = RefExpr->getReceiverType(S.Context);
833    QualType propType = RefExpr->getExplicitProperty()
834                          ->getUsageType(receiverType);
835    if (result.get()->getType()->isObjCIdType()) {
836      if (const ObjCObjectPointerType *ptr
837            = propType->getAs<ObjCObjectPointerType>()) {
838        if (!ptr->isObjCIdType())
839          result = S.ImpCastExprToType(result.get(), propType, CK_BitCast);
840      }
841    }
842    if (S.getLangOpts().ObjCAutoRefCount) {
843      Qualifiers::ObjCLifetime LT = propType.getObjCLifetime();
844      if (LT == Qualifiers::OCL_Weak)
845        if (!S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, RefExpr->getLocation()))
846              S.getCurFunction()->markSafeWeakUse(RefExpr);
847    }
848  }
849
850  return result;
851}
852
853/// Try to build this as a call to a getter that returns a reference.
854///
855/// \return true if it was possible, whether or not it actually
856///   succeeded
857bool ObjCPropertyOpBuilder::tryBuildGetOfReference(Expr *op,
858                                                   ExprResult &result) {
859  if (!S.getLangOpts().CPlusPlus) return false;
860
861  findGetter();
862  if (!Getter) {
863    // The property has no setter and no getter! This can happen if the type is
864    // invalid. Error have already been reported.
865    result = ExprError();
866    return true;
867  }
868
869  // Only do this if the getter returns an l-value reference type.
870  QualType resultType = Getter->getReturnType();
871  if (!resultType->isLValueReferenceType()) return false;
872
873  result = buildRValueOperation(op);
874  return true;
875}
876
877/// @property-specific behavior for doing assignments.
878ExprResult
879ObjCPropertyOpBuilder::buildAssignmentOperation(Scope *Sc,
880                                                SourceLocation opcLoc,
881                                                BinaryOperatorKind opcode,
882                                                Expr *LHS, Expr *RHS) {
883  assert(BinaryOperator::isAssignmentOp(opcode));
884
885  // If there's no setter, we have no choice but to try to assign to
886  // the result of the getter.
887  if (!findSetter()) {
888    ExprResult result;
889    if (tryBuildGetOfReference(LHS, result)) {
890      if (result.isInvalid()) return ExprError();
891      return S.BuildBinOp(Sc, opcLoc, opcode, result.get(), RHS);
892    }
893
894    // Otherwise, it's an error.
895    S.Diag(opcLoc, diag::err_nosetter_property_assignment)
896      << unsigned(RefExpr->isImplicitProperty())
897      << SetterSelector
898      << LHS->getSourceRange() << RHS->getSourceRange();
899    return ExprError();
900  }
901
902  // If there is a setter, we definitely want to use it.
903
904  // Verify that we can do a compound assignment.
905  if (opcode != BO_Assign && !findGetter()) {
906    S.Diag(opcLoc, diag::err_nogetter_property_compound_assignment)
907      << LHS->getSourceRange() << RHS->getSourceRange();
908    return ExprError();
909  }
910
911  ExprResult result =
912    PseudoOpBuilder::buildAssignmentOperation(Sc, opcLoc, opcode, LHS, RHS);
913  if (result.isInvalid()) return ExprError();
914
915  // Various warnings about property assignments in ARC.
916  if (S.getLangOpts().ObjCAutoRefCount && InstanceReceiver) {
917    S.checkRetainCycles(InstanceReceiver->getSourceExpr(), RHS);
918    S.checkUnsafeExprAssigns(opcLoc, LHS, RHS);
919  }
920
921  return result;
922}
923
924/// @property-specific behavior for doing increments and decrements.
925ExprResult
926ObjCPropertyOpBuilder::buildIncDecOperation(Scope *Sc, SourceLocation opcLoc,
927                                            UnaryOperatorKind opcode,
928                                            Expr *op) {
929  // If there's no setter, we have no choice but to try to assign to
930  // the result of the getter.
931  if (!findSetter()) {
932    ExprResult result;
933    if (tryBuildGetOfReference(op, result)) {
934      if (result.isInvalid()) return ExprError();
935      return S.BuildUnaryOp(Sc, opcLoc, opcode, result.get());
936    }
937
938    // Otherwise, it's an error.
939    S.Diag(opcLoc, diag::err_nosetter_property_incdec)
940      << unsigned(RefExpr->isImplicitProperty())
941      << unsigned(UnaryOperator::isDecrementOp(opcode))
942      << SetterSelector
943      << op->getSourceRange();
944    return ExprError();
945  }
946
947  // If there is a setter, we definitely want to use it.
948
949  // We also need a getter.
950  if (!findGetter()) {
951    assert(RefExpr->isImplicitProperty());
952    S.Diag(opcLoc, diag::err_nogetter_property_incdec)
953      << unsigned(UnaryOperator::isDecrementOp(opcode))
954      << GetterSelector
955      << op->getSourceRange();
956    return ExprError();
957  }
958
959  return PseudoOpBuilder::buildIncDecOperation(Sc, opcLoc, opcode, op);
960}
961
962ExprResult ObjCPropertyOpBuilder::complete(Expr *SyntacticForm) {
963  if (S.getLangOpts().ObjCAutoRefCount && isWeakProperty() &&
964      !S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak,
965                         SyntacticForm->getLocStart()))
966      S.recordUseOfEvaluatedWeak(SyntacticRefExpr,
967                                 SyntacticRefExpr->isMessagingGetter());
968
969  return PseudoOpBuilder::complete(SyntacticForm);
970}
971
972// ObjCSubscript build stuff.
973//
974
975/// objective-c subscripting-specific behavior for doing lvalue-to-rvalue
976/// conversion.
977/// FIXME. Remove this routine if it is proven that no additional
978/// specifity is needed.
979ExprResult ObjCSubscriptOpBuilder::buildRValueOperation(Expr *op) {
980  ExprResult result = PseudoOpBuilder::buildRValueOperation(op);
981  if (result.isInvalid()) return ExprError();
982  return result;
983}
984
985/// objective-c subscripting-specific  behavior for doing assignments.
986ExprResult
987ObjCSubscriptOpBuilder::buildAssignmentOperation(Scope *Sc,
988                                                SourceLocation opcLoc,
989                                                BinaryOperatorKind opcode,
990                                                Expr *LHS, Expr *RHS) {
991  assert(BinaryOperator::isAssignmentOp(opcode));
992  // There must be a method to do the Index'ed assignment.
993  if (!findAtIndexSetter())
994    return ExprError();
995
996  // Verify that we can do a compound assignment.
997  if (opcode != BO_Assign && !findAtIndexGetter())
998    return ExprError();
999
1000  ExprResult result =
1001  PseudoOpBuilder::buildAssignmentOperation(Sc, opcLoc, opcode, LHS, RHS);
1002  if (result.isInvalid()) return ExprError();
1003
1004  // Various warnings about objc Index'ed assignments in ARC.
1005  if (S.getLangOpts().ObjCAutoRefCount && InstanceBase) {
1006    S.checkRetainCycles(InstanceBase->getSourceExpr(), RHS);
1007    S.checkUnsafeExprAssigns(opcLoc, LHS, RHS);
1008  }
1009
1010  return result;
1011}
1012
1013/// Capture the base object of an Objective-C Index'ed expression.
1014Expr *ObjCSubscriptOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
1015  assert(InstanceBase == nullptr);
1016
1017  // Capture base expression in an OVE and rebuild the syntactic
1018  // form to use the OVE as its base expression.
1019  InstanceBase = capture(RefExpr->getBaseExpr());
1020  InstanceKey = capture(RefExpr->getKeyExpr());
1021
1022  syntacticBase =
1023      Rebuilder(S, [=](Expr *, unsigned Idx) -> Expr * {
1024        switch (Idx) {
1025        case 0:
1026          return InstanceBase;
1027        case 1:
1028          return InstanceKey;
1029        default:
1030          llvm_unreachable("Unexpected index for ObjCSubscriptExpr");
1031        }
1032      }).rebuild(syntacticBase);
1033
1034  return syntacticBase;
1035}
1036
1037/// CheckSubscriptingKind - This routine decide what type
1038/// of indexing represented by "FromE" is being done.
1039Sema::ObjCSubscriptKind
1040  Sema::CheckSubscriptingKind(Expr *FromE) {
1041  // If the expression already has integral or enumeration type, we're golden.
1042  QualType T = FromE->getType();
1043  if (T->isIntegralOrEnumerationType())
1044    return OS_Array;
1045
1046  // If we don't have a class type in C++, there's no way we can get an
1047  // expression of integral or enumeration type.
1048  const RecordType *RecordTy = T->getAs<RecordType>();
1049  if (!RecordTy &&
1050      (T->isObjCObjectPointerType() || T->isVoidPointerType()))
1051    // All other scalar cases are assumed to be dictionary indexing which
1052    // caller handles, with diagnostics if needed.
1053    return OS_Dictionary;
1054  if (!getLangOpts().CPlusPlus ||
1055      !RecordTy || RecordTy->isIncompleteType()) {
1056    // No indexing can be done. Issue diagnostics and quit.
1057    const Expr *IndexExpr = FromE->IgnoreParenImpCasts();
1058    if (isa<StringLiteral>(IndexExpr))
1059      Diag(FromE->getExprLoc(), diag::err_objc_subscript_pointer)
1060        << T << FixItHint::CreateInsertion(FromE->getExprLoc(), "@");
1061    else
1062      Diag(FromE->getExprLoc(), diag::err_objc_subscript_type_conversion)
1063        << T;
1064    return OS_Error;
1065  }
1066
1067  // We must have a complete class type.
1068  if (RequireCompleteType(FromE->getExprLoc(), T,
1069                          diag::err_objc_index_incomplete_class_type, FromE))
1070    return OS_Error;
1071
1072  // Look for a conversion to an integral, enumeration type, or
1073  // objective-C pointer type.
1074  int NoIntegrals=0, NoObjCIdPointers=0;
1075  SmallVector<CXXConversionDecl *, 4> ConversionDecls;
1076
1077  for (NamedDecl *D : cast<CXXRecordDecl>(RecordTy->getDecl())
1078                          ->getVisibleConversionFunctions()) {
1079    if (CXXConversionDecl *Conversion =
1080            dyn_cast<CXXConversionDecl>(D->getUnderlyingDecl())) {
1081      QualType CT = Conversion->getConversionType().getNonReferenceType();
1082      if (CT->isIntegralOrEnumerationType()) {
1083        ++NoIntegrals;
1084        ConversionDecls.push_back(Conversion);
1085      }
1086      else if (CT->isObjCIdType() ||CT->isBlockPointerType()) {
1087        ++NoObjCIdPointers;
1088        ConversionDecls.push_back(Conversion);
1089      }
1090    }
1091  }
1092  if (NoIntegrals ==1 && NoObjCIdPointers == 0)
1093    return OS_Array;
1094  if (NoIntegrals == 0 && NoObjCIdPointers == 1)
1095    return OS_Dictionary;
1096  if (NoIntegrals == 0 && NoObjCIdPointers == 0) {
1097    // No conversion function was found. Issue diagnostic and return.
1098    Diag(FromE->getExprLoc(), diag::err_objc_subscript_type_conversion)
1099      << FromE->getType();
1100    return OS_Error;
1101  }
1102  Diag(FromE->getExprLoc(), diag::err_objc_multiple_subscript_type_conversion)
1103      << FromE->getType();
1104  for (unsigned int i = 0; i < ConversionDecls.size(); i++)
1105    Diag(ConversionDecls[i]->getLocation(), diag::not_conv_function_declared_at);
1106
1107  return OS_Error;
1108}
1109
1110/// CheckKeyForObjCARCConversion - This routine suggests bridge casting of CF
1111/// objects used as dictionary subscript key objects.
1112static void CheckKeyForObjCARCConversion(Sema &S, QualType ContainerT,
1113                                         Expr *Key) {
1114  if (ContainerT.isNull())
1115    return;
1116  // dictionary subscripting.
1117  // - (id)objectForKeyedSubscript:(id)key;
1118  IdentifierInfo *KeyIdents[] = {
1119    &S.Context.Idents.get("objectForKeyedSubscript")
1120  };
1121  Selector GetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
1122  ObjCMethodDecl *Getter = S.LookupMethodInObjectType(GetterSelector, ContainerT,
1123                                                      true /*instance*/);
1124  if (!Getter)
1125    return;
1126  QualType T = Getter->parameters()[0]->getType();
1127  S.CheckObjCARCConversion(Key->getSourceRange(),
1128                         T, Key, Sema::CCK_ImplicitConversion);
1129}
1130
1131bool ObjCSubscriptOpBuilder::findAtIndexGetter() {
1132  if (AtIndexGetter)
1133    return true;
1134
1135  Expr *BaseExpr = RefExpr->getBaseExpr();
1136  QualType BaseT = BaseExpr->getType();
1137
1138  QualType ResultType;
1139  if (const ObjCObjectPointerType *PTy =
1140      BaseT->getAs<ObjCObjectPointerType>()) {
1141    ResultType = PTy->getPointeeType();
1142  }
1143  Sema::ObjCSubscriptKind Res =
1144    S.CheckSubscriptingKind(RefExpr->getKeyExpr());
1145  if (Res == Sema::OS_Error) {
1146    if (S.getLangOpts().ObjCAutoRefCount)
1147      CheckKeyForObjCARCConversion(S, ResultType,
1148                                   RefExpr->getKeyExpr());
1149    return false;
1150  }
1151  bool arrayRef = (Res == Sema::OS_Array);
1152
1153  if (ResultType.isNull()) {
1154    S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_base_type)
1155      << BaseExpr->getType() << arrayRef;
1156    return false;
1157  }
1158  if (!arrayRef) {
1159    // dictionary subscripting.
1160    // - (id)objectForKeyedSubscript:(id)key;
1161    IdentifierInfo *KeyIdents[] = {
1162      &S.Context.Idents.get("objectForKeyedSubscript")
1163    };
1164    AtIndexGetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
1165  }
1166  else {
1167    // - (id)objectAtIndexedSubscript:(size_t)index;
1168    IdentifierInfo *KeyIdents[] = {
1169      &S.Context.Idents.get("objectAtIndexedSubscript")
1170    };
1171
1172    AtIndexGetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
1173  }
1174
1175  AtIndexGetter = S.LookupMethodInObjectType(AtIndexGetterSelector, ResultType,
1176                                             true /*instance*/);
1177  bool receiverIdType = (BaseT->isObjCIdType() ||
1178                         BaseT->isObjCQualifiedIdType());
1179
1180  if (!AtIndexGetter && S.getLangOpts().DebuggerObjCLiteral) {
1181    AtIndexGetter = ObjCMethodDecl::Create(S.Context, SourceLocation(),
1182                           SourceLocation(), AtIndexGetterSelector,
1183                           S.Context.getObjCIdType() /*ReturnType*/,
1184                           nullptr /*TypeSourceInfo */,
1185                           S.Context.getTranslationUnitDecl(),
1186                           true /*Instance*/, false/*isVariadic*/,
1187                           /*isPropertyAccessor=*/false,
1188                           /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
1189                           ObjCMethodDecl::Required,
1190                           false);
1191    ParmVarDecl *Argument = ParmVarDecl::Create(S.Context, AtIndexGetter,
1192                                                SourceLocation(), SourceLocation(),
1193                                                arrayRef ? &S.Context.Idents.get("index")
1194                                                         : &S.Context.Idents.get("key"),
1195                                                arrayRef ? S.Context.UnsignedLongTy
1196                                                         : S.Context.getObjCIdType(),
1197                                                /*TInfo=*/nullptr,
1198                                                SC_None,
1199                                                nullptr);
1200    AtIndexGetter->setMethodParams(S.Context, Argument, None);
1201  }
1202
1203  if (!AtIndexGetter) {
1204    if (!receiverIdType) {
1205      S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_method_not_found)
1206      << BaseExpr->getType() << 0 << arrayRef;
1207      return false;
1208    }
1209    AtIndexGetter =
1210      S.LookupInstanceMethodInGlobalPool(AtIndexGetterSelector,
1211                                         RefExpr->getSourceRange(),
1212                                         true);
1213  }
1214
1215  if (AtIndexGetter) {
1216    QualType T = AtIndexGetter->parameters()[0]->getType();
1217    if ((arrayRef && !T->isIntegralOrEnumerationType()) ||
1218        (!arrayRef && !T->isObjCObjectPointerType())) {
1219      S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1220             arrayRef ? diag::err_objc_subscript_index_type
1221                      : diag::err_objc_subscript_key_type) << T;
1222      S.Diag(AtIndexGetter->parameters()[0]->getLocation(),
1223             diag::note_parameter_type) << T;
1224      return false;
1225    }
1226    QualType R = AtIndexGetter->getReturnType();
1227    if (!R->isObjCObjectPointerType()) {
1228      S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1229             diag::err_objc_indexing_method_result_type) << R << arrayRef;
1230      S.Diag(AtIndexGetter->getLocation(), diag::note_method_declared_at) <<
1231        AtIndexGetter->getDeclName();
1232    }
1233  }
1234  return true;
1235}
1236
1237bool ObjCSubscriptOpBuilder::findAtIndexSetter() {
1238  if (AtIndexSetter)
1239    return true;
1240
1241  Expr *BaseExpr = RefExpr->getBaseExpr();
1242  QualType BaseT = BaseExpr->getType();
1243
1244  QualType ResultType;
1245  if (const ObjCObjectPointerType *PTy =
1246      BaseT->getAs<ObjCObjectPointerType>()) {
1247    ResultType = PTy->getPointeeType();
1248  }
1249
1250  Sema::ObjCSubscriptKind Res =
1251    S.CheckSubscriptingKind(RefExpr->getKeyExpr());
1252  if (Res == Sema::OS_Error) {
1253    if (S.getLangOpts().ObjCAutoRefCount)
1254      CheckKeyForObjCARCConversion(S, ResultType,
1255                                   RefExpr->getKeyExpr());
1256    return false;
1257  }
1258  bool arrayRef = (Res == Sema::OS_Array);
1259
1260  if (ResultType.isNull()) {
1261    S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_base_type)
1262      << BaseExpr->getType() << arrayRef;
1263    return false;
1264  }
1265
1266  if (!arrayRef) {
1267    // dictionary subscripting.
1268    // - (void)setObject:(id)object forKeyedSubscript:(id)key;
1269    IdentifierInfo *KeyIdents[] = {
1270      &S.Context.Idents.get("setObject"),
1271      &S.Context.Idents.get("forKeyedSubscript")
1272    };
1273    AtIndexSetterSelector = S.Context.Selectors.getSelector(2, KeyIdents);
1274  }
1275  else {
1276    // - (void)setObject:(id)object atIndexedSubscript:(NSInteger)index;
1277    IdentifierInfo *KeyIdents[] = {
1278      &S.Context.Idents.get("setObject"),
1279      &S.Context.Idents.get("atIndexedSubscript")
1280    };
1281    AtIndexSetterSelector = S.Context.Selectors.getSelector(2, KeyIdents);
1282  }
1283  AtIndexSetter = S.LookupMethodInObjectType(AtIndexSetterSelector, ResultType,
1284                                             true /*instance*/);
1285
1286  bool receiverIdType = (BaseT->isObjCIdType() ||
1287                         BaseT->isObjCQualifiedIdType());
1288
1289  if (!AtIndexSetter && S.getLangOpts().DebuggerObjCLiteral) {
1290    TypeSourceInfo *ReturnTInfo = nullptr;
1291    QualType ReturnType = S.Context.VoidTy;
1292    AtIndexSetter = ObjCMethodDecl::Create(
1293        S.Context, SourceLocation(), SourceLocation(), AtIndexSetterSelector,
1294        ReturnType, ReturnTInfo, S.Context.getTranslationUnitDecl(),
1295        true /*Instance*/, false /*isVariadic*/,
1296        /*isPropertyAccessor=*/false,
1297        /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
1298        ObjCMethodDecl::Required, false);
1299    SmallVector<ParmVarDecl *, 2> Params;
1300    ParmVarDecl *object = ParmVarDecl::Create(S.Context, AtIndexSetter,
1301                                                SourceLocation(), SourceLocation(),
1302                                                &S.Context.Idents.get("object"),
1303                                                S.Context.getObjCIdType(),
1304                                                /*TInfo=*/nullptr,
1305                                                SC_None,
1306                                                nullptr);
1307    Params.push_back(object);
1308    ParmVarDecl *key = ParmVarDecl::Create(S.Context, AtIndexSetter,
1309                                                SourceLocation(), SourceLocation(),
1310                                                arrayRef ?  &S.Context.Idents.get("index")
1311                                                         :  &S.Context.Idents.get("key"),
1312                                                arrayRef ? S.Context.UnsignedLongTy
1313                                                         : S.Context.getObjCIdType(),
1314                                                /*TInfo=*/nullptr,
1315                                                SC_None,
1316                                                nullptr);
1317    Params.push_back(key);
1318    AtIndexSetter->setMethodParams(S.Context, Params, None);
1319  }
1320
1321  if (!AtIndexSetter) {
1322    if (!receiverIdType) {
1323      S.Diag(BaseExpr->getExprLoc(),
1324             diag::err_objc_subscript_method_not_found)
1325      << BaseExpr->getType() << 1 << arrayRef;
1326      return false;
1327    }
1328    AtIndexSetter =
1329      S.LookupInstanceMethodInGlobalPool(AtIndexSetterSelector,
1330                                         RefExpr->getSourceRange(),
1331                                         true);
1332  }
1333
1334  bool err = false;
1335  if (AtIndexSetter && arrayRef) {
1336    QualType T = AtIndexSetter->parameters()[1]->getType();
1337    if (!T->isIntegralOrEnumerationType()) {
1338      S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1339             diag::err_objc_subscript_index_type) << T;
1340      S.Diag(AtIndexSetter->parameters()[1]->getLocation(),
1341             diag::note_parameter_type) << T;
1342      err = true;
1343    }
1344    T = AtIndexSetter->parameters()[0]->getType();
1345    if (!T->isObjCObjectPointerType()) {
1346      S.Diag(RefExpr->getBaseExpr()->getExprLoc(),
1347             diag::err_objc_subscript_object_type) << T << arrayRef;
1348      S.Diag(AtIndexSetter->parameters()[0]->getLocation(),
1349             diag::note_parameter_type) << T;
1350      err = true;
1351    }
1352  }
1353  else if (AtIndexSetter && !arrayRef)
1354    for (unsigned i=0; i <2; i++) {
1355      QualType T = AtIndexSetter->parameters()[i]->getType();
1356      if (!T->isObjCObjectPointerType()) {
1357        if (i == 1)
1358          S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1359                 diag::err_objc_subscript_key_type) << T;
1360        else
1361          S.Diag(RefExpr->getBaseExpr()->getExprLoc(),
1362                 diag::err_objc_subscript_dic_object_type) << T;
1363        S.Diag(AtIndexSetter->parameters()[i]->getLocation(),
1364               diag::note_parameter_type) << T;
1365        err = true;
1366      }
1367    }
1368
1369  return !err;
1370}
1371
1372// Get the object at "Index" position in the container.
1373// [BaseExpr objectAtIndexedSubscript : IndexExpr];
1374ExprResult ObjCSubscriptOpBuilder::buildGet() {
1375  if (!findAtIndexGetter())
1376    return ExprError();
1377
1378  QualType receiverType = InstanceBase->getType();
1379
1380  // Build a message-send.
1381  ExprResult msg;
1382  Expr *Index = InstanceKey;
1383
1384  // Arguments.
1385  Expr *args[] = { Index };
1386  assert(InstanceBase);
1387  if (AtIndexGetter)
1388    S.DiagnoseUseOfDecl(AtIndexGetter, GenericLoc);
1389  msg = S.BuildInstanceMessageImplicit(InstanceBase, receiverType,
1390                                       GenericLoc,
1391                                       AtIndexGetterSelector, AtIndexGetter,
1392                                       MultiExprArg(args, 1));
1393  return msg;
1394}
1395
1396/// Store into the container the "op" object at "Index"'ed location
1397/// by building this messaging expression:
1398/// - (void)setObject:(id)object atIndexedSubscript:(NSInteger)index;
1399/// \param captureSetValueAsResult If true, capture the actual
1400///   value being set as the value of the property operation.
1401ExprResult ObjCSubscriptOpBuilder::buildSet(Expr *op, SourceLocation opcLoc,
1402                                           bool captureSetValueAsResult) {
1403  if (!findAtIndexSetter())
1404    return ExprError();
1405  if (AtIndexSetter)
1406    S.DiagnoseUseOfDecl(AtIndexSetter, GenericLoc);
1407  QualType receiverType = InstanceBase->getType();
1408  Expr *Index = InstanceKey;
1409
1410  // Arguments.
1411  Expr *args[] = { op, Index };
1412
1413  // Build a message-send.
1414  ExprResult msg = S.BuildInstanceMessageImplicit(InstanceBase, receiverType,
1415                                                  GenericLoc,
1416                                                  AtIndexSetterSelector,
1417                                                  AtIndexSetter,
1418                                                  MultiExprArg(args, 2));
1419
1420  if (!msg.isInvalid() && captureSetValueAsResult) {
1421    ObjCMessageExpr *msgExpr =
1422      cast<ObjCMessageExpr>(msg.get()->IgnoreImplicit());
1423    Expr *arg = msgExpr->getArg(0);
1424    if (CanCaptureValue(arg))
1425      msgExpr->setArg(0, captureValueAsResult(arg));
1426  }
1427
1428  return msg;
1429}
1430
1431//===----------------------------------------------------------------------===//
1432//  MSVC __declspec(property) references
1433//===----------------------------------------------------------------------===//
1434
1435MSPropertyRefExpr *
1436MSPropertyOpBuilder::getBaseMSProperty(MSPropertySubscriptExpr *E) {
1437  CallArgs.insert(CallArgs.begin(), E->getIdx());
1438  Expr *Base = E->getBase()->IgnoreParens();
1439  while (auto *MSPropSubscript = dyn_cast<MSPropertySubscriptExpr>(Base)) {
1440    CallArgs.insert(CallArgs.begin(), MSPropSubscript->getIdx());
1441    Base = MSPropSubscript->getBase()->IgnoreParens();
1442  }
1443  return cast<MSPropertyRefExpr>(Base);
1444}
1445
1446Expr *MSPropertyOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
1447  InstanceBase = capture(RefExpr->getBaseExpr());
1448  std::for_each(CallArgs.begin(), CallArgs.end(),
1449                [this](Expr *&Arg) { Arg = capture(Arg); });
1450  syntacticBase = Rebuilder(S, [=](Expr *, unsigned Idx) -> Expr * {
1451                    switch (Idx) {
1452                    case 0:
1453                      return InstanceBase;
1454                    default:
1455                      assert(Idx <= CallArgs.size());
1456                      return CallArgs[Idx - 1];
1457                    }
1458                  }).rebuild(syntacticBase);
1459
1460  return syntacticBase;
1461}
1462
1463ExprResult MSPropertyOpBuilder::buildGet() {
1464  if (!RefExpr->getPropertyDecl()->hasGetter()) {
1465    S.Diag(RefExpr->getMemberLoc(), diag::err_no_accessor_for_property)
1466      << 0 /* getter */ << RefExpr->getPropertyDecl();
1467    return ExprError();
1468  }
1469
1470  UnqualifiedId GetterName;
1471  IdentifierInfo *II = RefExpr->getPropertyDecl()->getGetterId();
1472  GetterName.setIdentifier(II, RefExpr->getMemberLoc());
1473  CXXScopeSpec SS;
1474  SS.Adopt(RefExpr->getQualifierLoc());
1475  ExprResult GetterExpr =
1476      S.ActOnMemberAccessExpr(S.getCurScope(), InstanceBase, SourceLocation(),
1477                              RefExpr->isArrow() ? tok::arrow : tok::period, SS,
1478                              SourceLocation(), GetterName, nullptr);
1479  if (GetterExpr.isInvalid()) {
1480    S.Diag(RefExpr->getMemberLoc(),
1481           diag::error_cannot_find_suitable_accessor) << 0 /* getter */
1482      << RefExpr->getPropertyDecl();
1483    return ExprError();
1484  }
1485
1486  return S.ActOnCallExpr(S.getCurScope(), GetterExpr.get(),
1487                         RefExpr->getSourceRange().getBegin(), CallArgs,
1488                         RefExpr->getSourceRange().getEnd());
1489}
1490
1491ExprResult MSPropertyOpBuilder::buildSet(Expr *op, SourceLocation sl,
1492                                         bool captureSetValueAsResult) {
1493  if (!RefExpr->getPropertyDecl()->hasSetter()) {
1494    S.Diag(RefExpr->getMemberLoc(), diag::err_no_accessor_for_property)
1495      << 1 /* setter */ << RefExpr->getPropertyDecl();
1496    return ExprError();
1497  }
1498
1499  UnqualifiedId SetterName;
1500  IdentifierInfo *II = RefExpr->getPropertyDecl()->getSetterId();
1501  SetterName.setIdentifier(II, RefExpr->getMemberLoc());
1502  CXXScopeSpec SS;
1503  SS.Adopt(RefExpr->getQualifierLoc());
1504  ExprResult SetterExpr =
1505      S.ActOnMemberAccessExpr(S.getCurScope(), InstanceBase, SourceLocation(),
1506                              RefExpr->isArrow() ? tok::arrow : tok::period, SS,
1507                              SourceLocation(), SetterName, nullptr);
1508  if (SetterExpr.isInvalid()) {
1509    S.Diag(RefExpr->getMemberLoc(),
1510           diag::error_cannot_find_suitable_accessor) << 1 /* setter */
1511      << RefExpr->getPropertyDecl();
1512    return ExprError();
1513  }
1514
1515  SmallVector<Expr*, 4> ArgExprs;
1516  ArgExprs.append(CallArgs.begin(), CallArgs.end());
1517  ArgExprs.push_back(op);
1518  return S.ActOnCallExpr(S.getCurScope(), SetterExpr.get(),
1519                         RefExpr->getSourceRange().getBegin(), ArgExprs,
1520                         op->getSourceRange().getEnd());
1521}
1522
1523//===----------------------------------------------------------------------===//
1524//  General Sema routines.
1525//===----------------------------------------------------------------------===//
1526
1527ExprResult Sema::checkPseudoObjectRValue(Expr *E) {
1528  Expr *opaqueRef = E->IgnoreParens();
1529  if (ObjCPropertyRefExpr *refExpr
1530        = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1531    ObjCPropertyOpBuilder builder(*this, refExpr);
1532    return builder.buildRValueOperation(E);
1533  }
1534  else if (ObjCSubscriptRefExpr *refExpr
1535           = dyn_cast<ObjCSubscriptRefExpr>(opaqueRef)) {
1536    ObjCSubscriptOpBuilder builder(*this, refExpr);
1537    return builder.buildRValueOperation(E);
1538  } else if (MSPropertyRefExpr *refExpr
1539             = dyn_cast<MSPropertyRefExpr>(opaqueRef)) {
1540    MSPropertyOpBuilder builder(*this, refExpr);
1541    return builder.buildRValueOperation(E);
1542  } else if (MSPropertySubscriptExpr *RefExpr =
1543                 dyn_cast<MSPropertySubscriptExpr>(opaqueRef)) {
1544    MSPropertyOpBuilder Builder(*this, RefExpr);
1545    return Builder.buildRValueOperation(E);
1546  } else {
1547    llvm_unreachable("unknown pseudo-object kind!");
1548  }
1549}
1550
1551/// Check an increment or decrement of a pseudo-object expression.
1552ExprResult Sema::checkPseudoObjectIncDec(Scope *Sc, SourceLocation opcLoc,
1553                                         UnaryOperatorKind opcode, Expr *op) {
1554  // Do nothing if the operand is dependent.
1555  if (op->isTypeDependent())
1556    return new (Context) UnaryOperator(op, opcode, Context.DependentTy,
1557                                       VK_RValue, OK_Ordinary, opcLoc);
1558
1559  assert(UnaryOperator::isIncrementDecrementOp(opcode));
1560  Expr *opaqueRef = op->IgnoreParens();
1561  if (ObjCPropertyRefExpr *refExpr
1562        = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1563    ObjCPropertyOpBuilder builder(*this, refExpr);
1564    return builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1565  } else if (isa<ObjCSubscriptRefExpr>(opaqueRef)) {
1566    Diag(opcLoc, diag::err_illegal_container_subscripting_op);
1567    return ExprError();
1568  } else if (MSPropertyRefExpr *refExpr
1569             = dyn_cast<MSPropertyRefExpr>(opaqueRef)) {
1570    MSPropertyOpBuilder builder(*this, refExpr);
1571    return builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1572  } else if (MSPropertySubscriptExpr *RefExpr
1573             = dyn_cast<MSPropertySubscriptExpr>(opaqueRef)) {
1574    MSPropertyOpBuilder Builder(*this, RefExpr);
1575    return Builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1576  } else {
1577    llvm_unreachable("unknown pseudo-object kind!");
1578  }
1579}
1580
1581ExprResult Sema::checkPseudoObjectAssignment(Scope *S, SourceLocation opcLoc,
1582                                             BinaryOperatorKind opcode,
1583                                             Expr *LHS, Expr *RHS) {
1584  // Do nothing if either argument is dependent.
1585  if (LHS->isTypeDependent() || RHS->isTypeDependent())
1586    return new (Context) BinaryOperator(LHS, RHS, opcode, Context.DependentTy,
1587                                        VK_RValue, OK_Ordinary, opcLoc, false);
1588
1589  // Filter out non-overload placeholder types in the RHS.
1590  if (RHS->getType()->isNonOverloadPlaceholderType()) {
1591    ExprResult result = CheckPlaceholderExpr(RHS);
1592    if (result.isInvalid()) return ExprError();
1593    RHS = result.get();
1594  }
1595
1596  Expr *opaqueRef = LHS->IgnoreParens();
1597  if (ObjCPropertyRefExpr *refExpr
1598        = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1599    ObjCPropertyOpBuilder builder(*this, refExpr);
1600    return builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1601  } else if (ObjCSubscriptRefExpr *refExpr
1602             = dyn_cast<ObjCSubscriptRefExpr>(opaqueRef)) {
1603    ObjCSubscriptOpBuilder builder(*this, refExpr);
1604    return builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1605  } else if (MSPropertyRefExpr *refExpr
1606             = dyn_cast<MSPropertyRefExpr>(opaqueRef)) {
1607      MSPropertyOpBuilder builder(*this, refExpr);
1608      return builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1609  } else if (MSPropertySubscriptExpr *RefExpr
1610             = dyn_cast<MSPropertySubscriptExpr>(opaqueRef)) {
1611      MSPropertyOpBuilder Builder(*this, RefExpr);
1612      return Builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1613  } else {
1614    llvm_unreachable("unknown pseudo-object kind!");
1615  }
1616}
1617
1618/// Given a pseudo-object reference, rebuild it without the opaque
1619/// values.  Basically, undo the behavior of rebuildAndCaptureObject.
1620/// This should never operate in-place.
1621static Expr *stripOpaqueValuesFromPseudoObjectRef(Sema &S, Expr *E) {
1622  return Rebuilder(S,
1623                   [=](Expr *E, unsigned) -> Expr * {
1624                     return cast<OpaqueValueExpr>(E)->getSourceExpr();
1625                   })
1626      .rebuild(E);
1627}
1628
1629/// Given a pseudo-object expression, recreate what it looks like
1630/// syntactically without the attendant OpaqueValueExprs.
1631///
1632/// This is a hack which should be removed when TreeTransform is
1633/// capable of rebuilding a tree without stripping implicit
1634/// operations.
1635Expr *Sema::recreateSyntacticForm(PseudoObjectExpr *E) {
1636  Expr *syntax = E->getSyntacticForm();
1637  if (UnaryOperator *uop = dyn_cast<UnaryOperator>(syntax)) {
1638    Expr *op = stripOpaqueValuesFromPseudoObjectRef(*this, uop->getSubExpr());
1639    return new (Context) UnaryOperator(op, uop->getOpcode(), uop->getType(),
1640                                       uop->getValueKind(), uop->getObjectKind(),
1641                                       uop->getOperatorLoc());
1642  } else if (CompoundAssignOperator *cop
1643               = dyn_cast<CompoundAssignOperator>(syntax)) {
1644    Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, cop->getLHS());
1645    Expr *rhs = cast<OpaqueValueExpr>(cop->getRHS())->getSourceExpr();
1646    return new (Context) CompoundAssignOperator(lhs, rhs, cop->getOpcode(),
1647                                                cop->getType(),
1648                                                cop->getValueKind(),
1649                                                cop->getObjectKind(),
1650                                                cop->getComputationLHSType(),
1651                                                cop->getComputationResultType(),
1652                                                cop->getOperatorLoc(), false);
1653  } else if (BinaryOperator *bop = dyn_cast<BinaryOperator>(syntax)) {
1654    Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, bop->getLHS());
1655    Expr *rhs = cast<OpaqueValueExpr>(bop->getRHS())->getSourceExpr();
1656    return new (Context) BinaryOperator(lhs, rhs, bop->getOpcode(),
1657                                        bop->getType(), bop->getValueKind(),
1658                                        bop->getObjectKind(),
1659                                        bop->getOperatorLoc(), false);
1660  } else {
1661    assert(syntax->hasPlaceholderType(BuiltinType::PseudoObject));
1662    return stripOpaqueValuesFromPseudoObjectRef(*this, syntax);
1663  }
1664}
1665