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