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