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