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