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