clang  3.8.0
SemaPseudoObject.cpp
Go to the documentation of this file.
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 
34 #include "clang/AST/ExprCXX.h"
35 #include "clang/AST/ExprObjC.h"
36 #include "clang/Basic/CharInfo.h"
37 #include "clang/Lex/Preprocessor.h"
39 #include "clang/Sema/ScopeInfo.h"
40 #include "llvm/ADT/SmallString.h"
41 
42 using namespace clang;
43 using namespace sema;
44 
45 namespace {
46  // Basically just a very focused copy of TreeTransform.
47  struct Rebuilder {
48  Sema &S;
49  unsigned MSPropertySubscriptCount;
50  typedef llvm::function_ref<Expr *(Expr *, unsigned)> SpecificRebuilderRefTy;
51  const SpecificRebuilderRefTy &SpecificCallback;
52  Rebuilder(Sema &S, const SpecificRebuilderRefTy &SpecificCallback)
53  : S(S), MSPropertySubscriptCount(0),
54  SpecificCallback(SpecificCallback) {}
55 
56  Expr *rebuildObjCPropertyRefExpr(ObjCPropertyRefExpr *refExpr) {
57  // Fortunately, the constraint that we're rebuilding something
58  // with a base limits the number of cases here.
59  if (refExpr->isClassReceiver() || refExpr->isSuperReceiver())
60  return refExpr;
61 
62  if (refExpr->isExplicitProperty()) {
63  return new (S.Context) ObjCPropertyRefExpr(
64  refExpr->getExplicitProperty(), refExpr->getType(),
65  refExpr->getValueKind(), refExpr->getObjectKind(),
66  refExpr->getLocation(), SpecificCallback(refExpr->getBase(), 0));
67  }
68  return new (S.Context) ObjCPropertyRefExpr(
69  refExpr->getImplicitPropertyGetter(),
70  refExpr->getImplicitPropertySetter(), refExpr->getType(),
71  refExpr->getValueKind(), refExpr->getObjectKind(),
72  refExpr->getLocation(), SpecificCallback(refExpr->getBase(), 0));
73  }
74  Expr *rebuildObjCSubscriptRefExpr(ObjCSubscriptRefExpr *refExpr) {
75  assert(refExpr->getBaseExpr());
76  assert(refExpr->getKeyExpr());
77 
78  return new (S.Context) ObjCSubscriptRefExpr(
79  SpecificCallback(refExpr->getBaseExpr(), 0),
80  SpecificCallback(refExpr->getKeyExpr(), 1), refExpr->getType(),
81  refExpr->getValueKind(), refExpr->getObjectKind(),
82  refExpr->getAtIndexMethodDecl(), refExpr->setAtIndexMethodDecl(),
83  refExpr->getRBracket());
84  }
85  Expr *rebuildMSPropertyRefExpr(MSPropertyRefExpr *refExpr) {
86  assert(refExpr->getBaseExpr());
87 
88  return new (S.Context) MSPropertyRefExpr(
89  SpecificCallback(refExpr->getBaseExpr(), 0),
90  refExpr->getPropertyDecl(), refExpr->isArrow(), refExpr->getType(),
91  refExpr->getValueKind(), refExpr->getQualifierLoc(),
92  refExpr->getMemberLoc());
93  }
94  Expr *rebuildMSPropertySubscriptExpr(MSPropertySubscriptExpr *refExpr) {
95  assert(refExpr->getBase());
96  assert(refExpr->getIdx());
97 
98  auto *NewBase = rebuild(refExpr->getBase());
99  ++MSPropertySubscriptCount;
100  return new (S.Context) MSPropertySubscriptExpr(
101  NewBase,
102  SpecificCallback(refExpr->getIdx(), MSPropertySubscriptCount),
103  refExpr->getType(), refExpr->getValueKind(), refExpr->getObjectKind(),
104  refExpr->getRBracketLoc());
105  }
106 
107  Expr *rebuild(Expr *e) {
108  // Fast path: nothing to look through.
109  if (auto *PRE = dyn_cast<ObjCPropertyRefExpr>(e))
110  return rebuildObjCPropertyRefExpr(PRE);
111  if (auto *SRE = dyn_cast<ObjCSubscriptRefExpr>(e))
112  return rebuildObjCSubscriptRefExpr(SRE);
113  if (auto *MSPRE = dyn_cast<MSPropertyRefExpr>(e))
114  return rebuildMSPropertyRefExpr(MSPRE);
115  if (auto *MSPSE = dyn_cast<MSPropertySubscriptExpr>(e))
116  return rebuildMSPropertySubscriptExpr(MSPSE);
117 
118  // Otherwise, we should look through and rebuild anything that
119  // IgnoreParens would.
120 
121  if (ParenExpr *parens = dyn_cast<ParenExpr>(e)) {
122  e = rebuild(parens->getSubExpr());
123  return new (S.Context) ParenExpr(parens->getLParen(),
124  parens->getRParen(),
125  e);
126  }
127 
128  if (UnaryOperator *uop = dyn_cast<UnaryOperator>(e)) {
129  assert(uop->getOpcode() == UO_Extension);
130  e = rebuild(uop->getSubExpr());
131  return new (S.Context) UnaryOperator(e, uop->getOpcode(),
132  uop->getType(),
133  uop->getValueKind(),
134  uop->getObjectKind(),
135  uop->getOperatorLoc());
136  }
137 
138  if (GenericSelectionExpr *gse = dyn_cast<GenericSelectionExpr>(e)) {
139  assert(!gse->isResultDependent());
140  unsigned resultIndex = gse->getResultIndex();
141  unsigned numAssocs = gse->getNumAssocs();
142 
143  SmallVector<Expr*, 8> assocs(numAssocs);
144  SmallVector<TypeSourceInfo*, 8> assocTypes(numAssocs);
145 
146  for (unsigned i = 0; i != numAssocs; ++i) {
147  Expr *assoc = gse->getAssocExpr(i);
148  if (i == resultIndex) assoc = rebuild(assoc);
149  assocs[i] = assoc;
150  assocTypes[i] = gse->getAssocTypeSourceInfo(i);
151  }
152 
153  return new (S.Context) GenericSelectionExpr(S.Context,
154  gse->getGenericLoc(),
155  gse->getControllingExpr(),
156  assocTypes,
157  assocs,
158  gse->getDefaultLoc(),
159  gse->getRParenLoc(),
160  gse->containsUnexpandedParameterPack(),
161  resultIndex);
162  }
163 
164  if (ChooseExpr *ce = dyn_cast<ChooseExpr>(e)) {
165  assert(!ce->isConditionDependent());
166 
167  Expr *LHS = ce->getLHS(), *RHS = ce->getRHS();
168  Expr *&rebuiltExpr = ce->isConditionTrue() ? LHS : RHS;
169  rebuiltExpr = rebuild(rebuiltExpr);
170 
171  return new (S.Context) ChooseExpr(ce->getBuiltinLoc(),
172  ce->getCond(),
173  LHS, RHS,
174  rebuiltExpr->getType(),
175  rebuiltExpr->getValueKind(),
176  rebuiltExpr->getObjectKind(),
177  ce->getRParenLoc(),
178  ce->isConditionTrue(),
179  rebuiltExpr->isTypeDependent(),
180  rebuiltExpr->isValueDependent());
181  }
182 
183  llvm_unreachable("bad expression to rebuild!");
184  }
185  };
186 
187  class PseudoOpBuilder {
188  public:
189  Sema &S;
190  unsigned ResultIndex;
191  SourceLocation GenericLoc;
192  SmallVector<Expr *, 4> Semantics;
193 
194  PseudoOpBuilder(Sema &S, SourceLocation genericLoc)
195  : S(S), ResultIndex(PseudoObjectExpr::NoResult),
196  GenericLoc(genericLoc) {}
197 
198  virtual ~PseudoOpBuilder() {}
199 
200  /// Add a normal semantic expression.
201  void addSemanticExpr(Expr *semantic) {
202  Semantics.push_back(semantic);
203  }
204 
205  /// Add the 'result' semantic expression.
206  void addResultSemanticExpr(Expr *resultExpr) {
207  assert(ResultIndex == PseudoObjectExpr::NoResult);
208  ResultIndex = Semantics.size();
209  Semantics.push_back(resultExpr);
210  }
211 
212  ExprResult buildRValueOperation(Expr *op);
213  ExprResult buildAssignmentOperation(Scope *Sc,
214  SourceLocation opLoc,
215  BinaryOperatorKind opcode,
216  Expr *LHS, Expr *RHS);
217  ExprResult buildIncDecOperation(Scope *Sc, SourceLocation opLoc,
218  UnaryOperatorKind opcode,
219  Expr *op);
220 
221  virtual ExprResult complete(Expr *syntacticForm);
222 
223  OpaqueValueExpr *capture(Expr *op);
224  OpaqueValueExpr *captureValueAsResult(Expr *op);
225 
226  void setResultToLastSemantic() {
227  assert(ResultIndex == PseudoObjectExpr::NoResult);
228  ResultIndex = Semantics.size() - 1;
229  }
230 
231  /// Return true if assignments have a non-void result.
232  static bool CanCaptureValue(Expr *exp) {
233  if (exp->isGLValue())
234  return true;
235  QualType ty = exp->getType();
236  assert(!ty->isIncompleteType());
237  assert(!ty->isDependentType());
238 
239  if (const CXXRecordDecl *ClassDecl = ty->getAsCXXRecordDecl())
240  return ClassDecl->isTriviallyCopyable();
241  return true;
242  }
243 
244  virtual Expr *rebuildAndCaptureObject(Expr *) = 0;
245  virtual ExprResult buildGet() = 0;
246  virtual ExprResult buildSet(Expr *, SourceLocation,
247  bool captureSetValueAsResult) = 0;
248  /// \brief Should the result of an assignment be the formal result of the
249  /// setter call or the value that was passed to the setter?
250  ///
251  /// Different pseudo-object language features use different language rules
252  /// for this.
253  /// The default is to use the set value. Currently, this affects the
254  /// behavior of simple assignments, compound assignments, and prefix
255  /// increment and decrement.
256  /// Postfix increment and decrement always use the getter result as the
257  /// expression result.
258  ///
259  /// If this method returns true, and the set value isn't capturable for
260  /// some reason, the result of the expression will be void.
261  virtual bool captureSetValueAsResult() const { return true; }
262  };
263 
264  /// A PseudoOpBuilder for Objective-C \@properties.
265  class ObjCPropertyOpBuilder : public PseudoOpBuilder {
266  ObjCPropertyRefExpr *RefExpr;
267  ObjCPropertyRefExpr *SyntacticRefExpr;
268  OpaqueValueExpr *InstanceReceiver;
269  ObjCMethodDecl *Getter;
270 
271  ObjCMethodDecl *Setter;
272  Selector SetterSelector;
273  Selector GetterSelector;
274 
275  public:
276  ObjCPropertyOpBuilder(Sema &S, ObjCPropertyRefExpr *refExpr) :
277  PseudoOpBuilder(S, refExpr->getLocation()), RefExpr(refExpr),
278  SyntacticRefExpr(nullptr), InstanceReceiver(nullptr), Getter(nullptr),
279  Setter(nullptr) {
280  }
281 
282  ExprResult buildRValueOperation(Expr *op);
283  ExprResult buildAssignmentOperation(Scope *Sc,
284  SourceLocation opLoc,
285  BinaryOperatorKind opcode,
286  Expr *LHS, Expr *RHS);
287  ExprResult buildIncDecOperation(Scope *Sc, SourceLocation opLoc,
288  UnaryOperatorKind opcode,
289  Expr *op);
290 
291  bool tryBuildGetOfReference(Expr *op, ExprResult &result);
292  bool findSetter(bool warn=true);
293  bool findGetter();
294  void DiagnoseUnsupportedPropertyUse();
295 
296  Expr *rebuildAndCaptureObject(Expr *syntacticBase) override;
297  ExprResult buildGet() override;
298  ExprResult buildSet(Expr *op, SourceLocation, bool) override;
299  ExprResult complete(Expr *SyntacticForm) override;
300 
301  bool isWeakProperty() const;
302  };
303 
304  /// A PseudoOpBuilder for Objective-C array/dictionary indexing.
305  class ObjCSubscriptOpBuilder : public PseudoOpBuilder {
306  ObjCSubscriptRefExpr *RefExpr;
307  OpaqueValueExpr *InstanceBase;
308  OpaqueValueExpr *InstanceKey;
309  ObjCMethodDecl *AtIndexGetter;
310  Selector AtIndexGetterSelector;
311 
312  ObjCMethodDecl *AtIndexSetter;
313  Selector AtIndexSetterSelector;
314 
315  public:
316  ObjCSubscriptOpBuilder(Sema &S, ObjCSubscriptRefExpr *refExpr) :
317  PseudoOpBuilder(S, refExpr->getSourceRange().getBegin()),
318  RefExpr(refExpr),
319  InstanceBase(nullptr), InstanceKey(nullptr),
320  AtIndexGetter(nullptr), AtIndexSetter(nullptr) {}
321 
322  ExprResult buildRValueOperation(Expr *op);
323  ExprResult buildAssignmentOperation(Scope *Sc,
324  SourceLocation opLoc,
325  BinaryOperatorKind opcode,
326  Expr *LHS, Expr *RHS);
327  Expr *rebuildAndCaptureObject(Expr *syntacticBase) override;
328 
329  bool findAtIndexGetter();
330  bool findAtIndexSetter();
331 
332  ExprResult buildGet() override;
333  ExprResult buildSet(Expr *op, SourceLocation, bool) override;
334  };
335 
336  class MSPropertyOpBuilder : public PseudoOpBuilder {
337  MSPropertyRefExpr *RefExpr;
338  OpaqueValueExpr *InstanceBase;
339  SmallVector<Expr *, 4> CallArgs;
340 
341  MSPropertyRefExpr *getBaseMSProperty(MSPropertySubscriptExpr *E);
342 
343  public:
344  MSPropertyOpBuilder(Sema &S, MSPropertyRefExpr *refExpr) :
345  PseudoOpBuilder(S, refExpr->getSourceRange().getBegin()),
346  RefExpr(refExpr), InstanceBase(nullptr) {}
347  MSPropertyOpBuilder(Sema &S, MSPropertySubscriptExpr *refExpr)
348  : PseudoOpBuilder(S, refExpr->getSourceRange().getBegin()),
349  InstanceBase(nullptr) {
350  RefExpr = getBaseMSProperty(refExpr);
351  }
352 
353  Expr *rebuildAndCaptureObject(Expr *) override;
354  ExprResult buildGet() override;
355  ExprResult buildSet(Expr *op, SourceLocation, bool) override;
356  bool captureSetValueAsResult() const override { return false; }
357  };
358 }
359 
360 /// Capture the given expression in an OpaqueValueExpr.
361 OpaqueValueExpr *PseudoOpBuilder::capture(Expr *e) {
362  // Make a new OVE whose source is the given expression.
363  OpaqueValueExpr *captured =
364  new (S.Context) OpaqueValueExpr(GenericLoc, e->getType(),
365  e->getValueKind(), e->getObjectKind(),
366  e);
367 
368  // Make sure we bind that in the semantics.
369  addSemanticExpr(captured);
370  return captured;
371 }
372 
373 /// Capture the given expression as the result of this pseudo-object
374 /// operation. This routine is safe against expressions which may
375 /// already be captured.
376 ///
377 /// \returns the captured expression, which will be the
378 /// same as the input if the input was already captured
379 OpaqueValueExpr *PseudoOpBuilder::captureValueAsResult(Expr *e) {
380  assert(ResultIndex == PseudoObjectExpr::NoResult);
381 
382  // If the expression hasn't already been captured, just capture it
383  // and set the new semantic
384  if (!isa<OpaqueValueExpr>(e)) {
385  OpaqueValueExpr *cap = capture(e);
386  setResultToLastSemantic();
387  return cap;
388  }
389 
390  // Otherwise, it must already be one of our semantic expressions;
391  // set ResultIndex to its index.
392  unsigned index = 0;
393  for (;; ++index) {
394  assert(index < Semantics.size() &&
395  "captured expression not found in semantics!");
396  if (e == Semantics[index]) break;
397  }
398  ResultIndex = index;
399  return cast<OpaqueValueExpr>(e);
400 }
401 
402 /// The routine which creates the final PseudoObjectExpr.
403 ExprResult PseudoOpBuilder::complete(Expr *syntactic) {
404  return PseudoObjectExpr::Create(S.Context, syntactic,
405  Semantics, ResultIndex);
406 }
407 
408 /// The main skeleton for building an r-value operation.
409 ExprResult PseudoOpBuilder::buildRValueOperation(Expr *op) {
410  Expr *syntacticBase = rebuildAndCaptureObject(op);
411 
412  ExprResult getExpr = buildGet();
413  if (getExpr.isInvalid()) return ExprError();
414  addResultSemanticExpr(getExpr.get());
415 
416  return complete(syntacticBase);
417 }
418 
419 /// The basic skeleton for building a simple or compound
420 /// assignment operation.
422 PseudoOpBuilder::buildAssignmentOperation(Scope *Sc, SourceLocation opcLoc,
423  BinaryOperatorKind opcode,
424  Expr *LHS, Expr *RHS) {
425  assert(BinaryOperator::isAssignmentOp(opcode));
426 
427  Expr *syntacticLHS = rebuildAndCaptureObject(LHS);
428  OpaqueValueExpr *capturedRHS = capture(RHS);
429 
430  // In some very specific cases, semantic analysis of the RHS as an
431  // expression may require it to be rewritten. In these cases, we
432  // cannot safely keep the OVE around. Fortunately, we don't really
433  // need to: we don't use this particular OVE in multiple places, and
434  // no clients rely that closely on matching up expressions in the
435  // semantic expression with expressions from the syntactic form.
436  Expr *semanticRHS = capturedRHS;
437  if (RHS->hasPlaceholderType() || isa<InitListExpr>(RHS)) {
438  semanticRHS = RHS;
439  Semantics.pop_back();
440  }
441 
442  Expr *syntactic;
443 
444  ExprResult result;
445  if (opcode == BO_Assign) {
446  result = semanticRHS;
447  syntactic = new (S.Context) BinaryOperator(syntacticLHS, capturedRHS,
448  opcode, capturedRHS->getType(),
449  capturedRHS->getValueKind(),
450  OK_Ordinary, opcLoc, false);
451  } else {
452  ExprResult opLHS = buildGet();
453  if (opLHS.isInvalid()) return ExprError();
454 
455  // Build an ordinary, non-compound operation.
456  BinaryOperatorKind nonCompound =
458  result = S.BuildBinOp(Sc, opcLoc, nonCompound, opLHS.get(), semanticRHS);
459  if (result.isInvalid()) return ExprError();
460 
461  syntactic =
462  new (S.Context) CompoundAssignOperator(syntacticLHS, capturedRHS, opcode,
463  result.get()->getType(),
464  result.get()->getValueKind(),
465  OK_Ordinary,
466  opLHS.get()->getType(),
467  result.get()->getType(),
468  opcLoc, false);
469  }
470 
471  // The result of the assignment, if not void, is the value set into
472  // the l-value.
473  result = buildSet(result.get(), opcLoc, captureSetValueAsResult());
474  if (result.isInvalid()) return ExprError();
475  addSemanticExpr(result.get());
476  if (!captureSetValueAsResult() && !result.get()->getType()->isVoidType() &&
477  (result.get()->isTypeDependent() || CanCaptureValue(result.get())))
478  setResultToLastSemantic();
479 
480  return complete(syntactic);
481 }
482 
483 /// The basic skeleton for building an increment or decrement
484 /// operation.
486 PseudoOpBuilder::buildIncDecOperation(Scope *Sc, SourceLocation opcLoc,
487  UnaryOperatorKind opcode,
488  Expr *op) {
490 
491  Expr *syntacticOp = rebuildAndCaptureObject(op);
492 
493  // Load the value.
494  ExprResult result = buildGet();
495  if (result.isInvalid()) return ExprError();
496 
497  QualType resultType = result.get()->getType();
498 
499  // That's the postfix result.
500  if (UnaryOperator::isPostfix(opcode) &&
501  (result.get()->isTypeDependent() || CanCaptureValue(result.get()))) {
502  result = capture(result.get());
503  setResultToLastSemantic();
504  }
505 
506  // Add or subtract a literal 1.
507  llvm::APInt oneV(S.Context.getTypeSize(S.Context.IntTy), 1);
509  GenericLoc);
510 
511  if (UnaryOperator::isIncrementOp(opcode)) {
512  result = S.BuildBinOp(Sc, opcLoc, BO_Add, result.get(), one);
513  } else {
514  result = S.BuildBinOp(Sc, opcLoc, BO_Sub, result.get(), one);
515  }
516  if (result.isInvalid()) return ExprError();
517 
518  // Store that back into the result. The value stored is the result
519  // of a prefix operation.
520  result = buildSet(result.get(), opcLoc, UnaryOperator::isPrefix(opcode) &&
521  captureSetValueAsResult());
522  if (result.isInvalid()) return ExprError();
523  addSemanticExpr(result.get());
524  if (UnaryOperator::isPrefix(opcode) && !captureSetValueAsResult() &&
525  !result.get()->getType()->isVoidType() &&
526  (result.get()->isTypeDependent() || CanCaptureValue(result.get())))
527  setResultToLastSemantic();
528 
529  UnaryOperator *syntactic =
530  new (S.Context) UnaryOperator(syntacticOp, opcode, resultType,
531  VK_LValue, OK_Ordinary, opcLoc);
532  return complete(syntactic);
533 }
534 
535 
536 //===----------------------------------------------------------------------===//
537 // Objective-C @property and implicit property references
538 //===----------------------------------------------------------------------===//
539 
540 /// Look up a method in the receiver type of an Objective-C property
541 /// reference.
543  const ObjCPropertyRefExpr *PRE) {
544  if (PRE->isObjectReceiver()) {
545  const ObjCObjectPointerType *PT =
547 
548  // Special case for 'self' in class method implementations.
549  if (PT->isObjCClassType() &&
550  S.isSelfExpr(const_cast<Expr*>(PRE->getBase()))) {
551  // This cast is safe because isSelfExpr is only true within
552  // methods.
553  ObjCMethodDecl *method =
554  cast<ObjCMethodDecl>(S.CurContext->getNonClosureAncestor());
555  return S.LookupMethodInObjectType(sel,
557  /*instance*/ false);
558  }
559 
560  return S.LookupMethodInObjectType(sel, PT->getPointeeType(), true);
561  }
562 
563  if (PRE->isSuperReceiver()) {
564  if (const ObjCObjectPointerType *PT =
566  return S.LookupMethodInObjectType(sel, PT->getPointeeType(), true);
567 
568  return S.LookupMethodInObjectType(sel, PRE->getSuperReceiverType(), false);
569  }
570 
571  assert(PRE->isClassReceiver() && "Invalid expression");
573  return S.LookupMethodInObjectType(sel, IT, false);
574 }
575 
576 bool ObjCPropertyOpBuilder::isWeakProperty() const {
577  QualType T;
578  if (RefExpr->isExplicitProperty()) {
579  const ObjCPropertyDecl *Prop = RefExpr->getExplicitProperty();
581  return !Prop->hasAttr<IBOutletAttr>();
582 
583  T = Prop->getType();
584  } else if (Getter) {
585  T = Getter->getReturnType();
586  } else {
587  return false;
588  }
589 
591 }
592 
593 bool ObjCPropertyOpBuilder::findGetter() {
594  if (Getter) return true;
595 
596  // For implicit properties, just trust the lookup we already did.
597  if (RefExpr->isImplicitProperty()) {
598  if ((Getter = RefExpr->getImplicitPropertyGetter())) {
599  GetterSelector = Getter->getSelector();
600  return true;
601  }
602  else {
603  // Must build the getter selector the hard way.
604  ObjCMethodDecl *setter = RefExpr->getImplicitPropertySetter();
605  assert(setter && "both setter and getter are null - cannot happen");
606  IdentifierInfo *setterName =
608  IdentifierInfo *getterName =
609  &S.Context.Idents.get(setterName->getName().substr(3));
610  GetterSelector =
611  S.PP.getSelectorTable().getNullarySelector(getterName);
612  return false;
613  }
614  }
615 
616  ObjCPropertyDecl *prop = RefExpr->getExplicitProperty();
617  Getter = LookupMethodInReceiverType(S, prop->getGetterName(), RefExpr);
618  return (Getter != nullptr);
619 }
620 
621 /// Try to find the most accurate setter declaration for the property
622 /// reference.
623 ///
624 /// \return true if a setter was found, in which case Setter
625 bool ObjCPropertyOpBuilder::findSetter(bool warn) {
626  // For implicit properties, just trust the lookup we already did.
627  if (RefExpr->isImplicitProperty()) {
628  if (ObjCMethodDecl *setter = RefExpr->getImplicitPropertySetter()) {
629  Setter = setter;
630  SetterSelector = setter->getSelector();
631  return true;
632  } else {
633  IdentifierInfo *getterName =
634  RefExpr->getImplicitPropertyGetter()->getSelector()
635  .getIdentifierInfoForSlot(0);
636  SetterSelector =
639  getterName);
640  return false;
641  }
642  }
643 
644  // For explicit properties, this is more involved.
645  ObjCPropertyDecl *prop = RefExpr->getExplicitProperty();
646  SetterSelector = prop->getSetterName();
647 
648  // Do a normal method lookup first.
649  if (ObjCMethodDecl *setter =
650  LookupMethodInReceiverType(S, SetterSelector, RefExpr)) {
651  if (setter->isPropertyAccessor() && warn)
652  if (const ObjCInterfaceDecl *IFace =
653  dyn_cast<ObjCInterfaceDecl>(setter->getDeclContext())) {
654  StringRef thisPropertyName = prop->getName();
655  // Try flipping the case of the first character.
656  char front = thisPropertyName.front();
657  front = isLowercase(front) ? toUppercase(front) : toLowercase(front);
658  SmallString<100> PropertyName = thisPropertyName;
659  PropertyName[0] = front;
660  IdentifierInfo *AltMember = &S.PP.getIdentifierTable().get(PropertyName);
661  if (ObjCPropertyDecl *prop1 = IFace->FindPropertyDeclaration(AltMember))
662  if (prop != prop1 && (prop1->getSetterMethodDecl() == setter)) {
663  S.Diag(RefExpr->getExprLoc(), diag::error_property_setter_ambiguous_use)
664  << prop << prop1 << setter->getSelector();
665  S.Diag(prop->getLocation(), diag::note_property_declare);
666  S.Diag(prop1->getLocation(), diag::note_property_declare);
667  }
668  }
669  Setter = setter;
670  return true;
671  }
672 
673  // That can fail in the somewhat crazy situation that we're
674  // type-checking a message send within the @interface declaration
675  // that declared the @property. But it's not clear that that's
676  // valuable to support.
677 
678  return false;
679 }
680 
681 void ObjCPropertyOpBuilder::DiagnoseUnsupportedPropertyUse() {
683  S.getCurLexicalContext()->getDeclKind() != Decl::ObjCCategoryImpl &&
684  S.getCurLexicalContext()->getDeclKind() != Decl::ObjCImplementation) {
685  if (ObjCPropertyDecl *prop = RefExpr->getExplicitProperty()) {
686  S.Diag(RefExpr->getLocation(),
687  diag::err_property_function_in_objc_container);
688  S.Diag(prop->getLocation(), diag::note_property_declare);
689  }
690  }
691 }
692 
693 /// Capture the base object of an Objective-C property expression.
694 Expr *ObjCPropertyOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
695  assert(InstanceReceiver == nullptr);
696 
697  // If we have a base, capture it in an OVE and rebuild the syntactic
698  // form to use the OVE as its base.
699  if (RefExpr->isObjectReceiver()) {
700  InstanceReceiver = capture(RefExpr->getBase());
701  syntacticBase = Rebuilder(S, [=](Expr *, unsigned) -> Expr * {
702  return InstanceReceiver;
703  }).rebuild(syntacticBase);
704  }
705 
706  if (ObjCPropertyRefExpr *
707  refE = dyn_cast<ObjCPropertyRefExpr>(syntacticBase->IgnoreParens()))
708  SyntacticRefExpr = refE;
709 
710  return syntacticBase;
711 }
712 
713 /// Load from an Objective-C property reference.
714 ExprResult ObjCPropertyOpBuilder::buildGet() {
715  findGetter();
716  if (!Getter) {
717  DiagnoseUnsupportedPropertyUse();
718  return ExprError();
719  }
720 
721  if (SyntacticRefExpr)
722  SyntacticRefExpr->setIsMessagingGetter();
723 
724  QualType receiverType = RefExpr->getReceiverType(S.Context);
725  if (!Getter->isImplicit())
726  S.DiagnoseUseOfDecl(Getter, GenericLoc, nullptr, true);
727  // Build a message-send.
728  ExprResult msg;
729  if ((Getter->isInstanceMethod() && !RefExpr->isClassReceiver()) ||
730  RefExpr->isObjectReceiver()) {
731  assert(InstanceReceiver || RefExpr->isSuperReceiver());
732  msg = S.BuildInstanceMessageImplicit(InstanceReceiver, receiverType,
733  GenericLoc, Getter->getSelector(),
734  Getter, None);
735  } else {
736  msg = S.BuildClassMessageImplicit(receiverType, RefExpr->isSuperReceiver(),
737  GenericLoc, Getter->getSelector(),
738  Getter, None);
739  }
740  return msg;
741 }
742 
743 /// Store to an Objective-C property reference.
744 ///
745 /// \param captureSetValueAsResult If true, capture the actual
746 /// value being set as the value of the property operation.
747 ExprResult ObjCPropertyOpBuilder::buildSet(Expr *op, SourceLocation opcLoc,
748  bool captureSetValueAsResult) {
749  if (!findSetter(false)) {
750  DiagnoseUnsupportedPropertyUse();
751  return ExprError();
752  }
753 
754  if (SyntacticRefExpr)
755  SyntacticRefExpr->setIsMessagingSetter();
756 
757  QualType receiverType = RefExpr->getReceiverType(S.Context);
758 
759  // Use assignment constraints when possible; they give us better
760  // diagnostics. "When possible" basically means anything except a
761  // C++ class type.
762  if (!S.getLangOpts().CPlusPlus || !op->getType()->isRecordType()) {
763  QualType paramType = (*Setter->param_begin())->getType()
765  receiverType,
766  Setter->getDeclContext(),
768  if (!S.getLangOpts().CPlusPlus || !paramType->isRecordType()) {
769  ExprResult opResult = op;
770  Sema::AssignConvertType assignResult
771  = S.CheckSingleAssignmentConstraints(paramType, opResult);
772  if (S.DiagnoseAssignmentResult(assignResult, opcLoc, paramType,
773  op->getType(), opResult.get(),
775  return ExprError();
776 
777  op = opResult.get();
778  assert(op && "successful assignment left argument invalid?");
779  }
780  }
781 
782  // Arguments.
783  Expr *args[] = { op };
784 
785  // Build a message-send.
786  ExprResult msg;
787  if (!Setter->isImplicit())
788  S.DiagnoseUseOfDecl(Setter, GenericLoc, nullptr, true);
789  if ((Setter->isInstanceMethod() && !RefExpr->isClassReceiver()) ||
790  RefExpr->isObjectReceiver()) {
791  msg = S.BuildInstanceMessageImplicit(InstanceReceiver, receiverType,
792  GenericLoc, SetterSelector, Setter,
793  MultiExprArg(args, 1));
794  } else {
795  msg = S.BuildClassMessageImplicit(receiverType, RefExpr->isSuperReceiver(),
796  GenericLoc,
797  SetterSelector, Setter,
798  MultiExprArg(args, 1));
799  }
800 
801  if (!msg.isInvalid() && captureSetValueAsResult) {
802  ObjCMessageExpr *msgExpr =
803  cast<ObjCMessageExpr>(msg.get()->IgnoreImplicit());
804  Expr *arg = msgExpr->getArg(0);
805  if (CanCaptureValue(arg))
806  msgExpr->setArg(0, captureValueAsResult(arg));
807  }
808 
809  return msg;
810 }
811 
812 /// @property-specific behavior for doing lvalue-to-rvalue conversion.
813 ExprResult ObjCPropertyOpBuilder::buildRValueOperation(Expr *op) {
814  // Explicit properties always have getters, but implicit ones don't.
815  // Check that before proceeding.
816  if (RefExpr->isImplicitProperty() && !RefExpr->getImplicitPropertyGetter()) {
817  S.Diag(RefExpr->getLocation(), diag::err_getter_not_found)
818  << RefExpr->getSourceRange();
819  return ExprError();
820  }
821 
822  ExprResult result = PseudoOpBuilder::buildRValueOperation(op);
823  if (result.isInvalid()) return ExprError();
824 
825  if (RefExpr->isExplicitProperty() && !Getter->hasRelatedResultType())
826  S.DiagnosePropertyAccessorMismatch(RefExpr->getExplicitProperty(),
827  Getter, RefExpr->getLocation());
828 
829  // As a special case, if the method returns 'id', try to get
830  // a better type from the property.
831  if (RefExpr->isExplicitProperty() && result.get()->isRValue()) {
832  QualType receiverType = RefExpr->getReceiverType(S.Context);
833  QualType propType = RefExpr->getExplicitProperty()
834  ->getUsageType(receiverType);
835  if (result.get()->getType()->isObjCIdType()) {
836  if (const ObjCObjectPointerType *ptr
837  = propType->getAs<ObjCObjectPointerType>()) {
838  if (!ptr->isObjCIdType())
839  result = S.ImpCastExprToType(result.get(), propType, CK_BitCast);
840  }
841  }
842  if (S.getLangOpts().ObjCAutoRefCount) {
844  if (LT == Qualifiers::OCL_Weak)
845  if (!S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, RefExpr->getLocation()))
846  S.getCurFunction()->markSafeWeakUse(RefExpr);
847  }
848  }
849 
850  return result;
851 }
852 
853 /// Try to build this as a call to a getter that returns a reference.
854 ///
855 /// \return true if it was possible, whether or not it actually
856 /// succeeded
857 bool ObjCPropertyOpBuilder::tryBuildGetOfReference(Expr *op,
858  ExprResult &result) {
859  if (!S.getLangOpts().CPlusPlus) return false;
860 
861  findGetter();
862  if (!Getter) {
863  // The property has no setter and no getter! This can happen if the type is
864  // invalid. Error have already been reported.
865  result = ExprError();
866  return true;
867  }
868 
869  // Only do this if the getter returns an l-value reference type.
870  QualType resultType = Getter->getReturnType();
871  if (!resultType->isLValueReferenceType()) return false;
872 
873  result = buildRValueOperation(op);
874  return true;
875 }
876 
877 /// @property-specific behavior for doing assignments.
879 ObjCPropertyOpBuilder::buildAssignmentOperation(Scope *Sc,
880  SourceLocation opcLoc,
881  BinaryOperatorKind opcode,
882  Expr *LHS, Expr *RHS) {
883  assert(BinaryOperator::isAssignmentOp(opcode));
884 
885  // If there's no setter, we have no choice but to try to assign to
886  // the result of the getter.
887  if (!findSetter()) {
888  ExprResult result;
889  if (tryBuildGetOfReference(LHS, result)) {
890  if (result.isInvalid()) return ExprError();
891  return S.BuildBinOp(Sc, opcLoc, opcode, result.get(), RHS);
892  }
893 
894  // Otherwise, it's an error.
895  S.Diag(opcLoc, diag::err_nosetter_property_assignment)
896  << unsigned(RefExpr->isImplicitProperty())
897  << SetterSelector
898  << LHS->getSourceRange() << RHS->getSourceRange();
899  return ExprError();
900  }
901 
902  // If there is a setter, we definitely want to use it.
903 
904  // Verify that we can do a compound assignment.
905  if (opcode != BO_Assign && !findGetter()) {
906  S.Diag(opcLoc, diag::err_nogetter_property_compound_assignment)
907  << LHS->getSourceRange() << RHS->getSourceRange();
908  return ExprError();
909  }
910 
911  ExprResult result =
912  PseudoOpBuilder::buildAssignmentOperation(Sc, opcLoc, opcode, LHS, RHS);
913  if (result.isInvalid()) return ExprError();
914 
915  // Various warnings about property assignments in ARC.
916  if (S.getLangOpts().ObjCAutoRefCount && InstanceReceiver) {
917  S.checkRetainCycles(InstanceReceiver->getSourceExpr(), RHS);
918  S.checkUnsafeExprAssigns(opcLoc, LHS, RHS);
919  }
920 
921  return result;
922 }
923 
924 /// @property-specific behavior for doing increments and decrements.
926 ObjCPropertyOpBuilder::buildIncDecOperation(Scope *Sc, SourceLocation opcLoc,
927  UnaryOperatorKind opcode,
928  Expr *op) {
929  // If there's no setter, we have no choice but to try to assign to
930  // the result of the getter.
931  if (!findSetter()) {
932  ExprResult result;
933  if (tryBuildGetOfReference(op, result)) {
934  if (result.isInvalid()) return ExprError();
935  return S.BuildUnaryOp(Sc, opcLoc, opcode, result.get());
936  }
937 
938  // Otherwise, it's an error.
939  S.Diag(opcLoc, diag::err_nosetter_property_incdec)
940  << unsigned(RefExpr->isImplicitProperty())
941  << unsigned(UnaryOperator::isDecrementOp(opcode))
942  << SetterSelector
943  << op->getSourceRange();
944  return ExprError();
945  }
946 
947  // If there is a setter, we definitely want to use it.
948 
949  // We also need a getter.
950  if (!findGetter()) {
951  assert(RefExpr->isImplicitProperty());
952  S.Diag(opcLoc, diag::err_nogetter_property_incdec)
954  << GetterSelector
955  << op->getSourceRange();
956  return ExprError();
957  }
958 
959  return PseudoOpBuilder::buildIncDecOperation(Sc, opcLoc, opcode, op);
960 }
961 
962 ExprResult ObjCPropertyOpBuilder::complete(Expr *SyntacticForm) {
963  if (S.getLangOpts().ObjCAutoRefCount && isWeakProperty() &&
964  !S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak,
965  SyntacticForm->getLocStart()))
966  S.recordUseOfEvaluatedWeak(SyntacticRefExpr,
967  SyntacticRefExpr->isMessagingGetter());
968 
969  return PseudoOpBuilder::complete(SyntacticForm);
970 }
971 
972 // ObjCSubscript build stuff.
973 //
974 
975 /// objective-c subscripting-specific behavior for doing lvalue-to-rvalue
976 /// conversion.
977 /// FIXME. Remove this routine if it is proven that no additional
978 /// specifity is needed.
979 ExprResult ObjCSubscriptOpBuilder::buildRValueOperation(Expr *op) {
980  ExprResult result = PseudoOpBuilder::buildRValueOperation(op);
981  if (result.isInvalid()) return ExprError();
982  return result;
983 }
984 
985 /// objective-c subscripting-specific behavior for doing assignments.
987 ObjCSubscriptOpBuilder::buildAssignmentOperation(Scope *Sc,
988  SourceLocation opcLoc,
989  BinaryOperatorKind opcode,
990  Expr *LHS, Expr *RHS) {
991  assert(BinaryOperator::isAssignmentOp(opcode));
992  // There must be a method to do the Index'ed assignment.
993  if (!findAtIndexSetter())
994  return ExprError();
995 
996  // Verify that we can do a compound assignment.
997  if (opcode != BO_Assign && !findAtIndexGetter())
998  return ExprError();
999 
1000  ExprResult result =
1001  PseudoOpBuilder::buildAssignmentOperation(Sc, opcLoc, opcode, LHS, RHS);
1002  if (result.isInvalid()) return ExprError();
1003 
1004  // Various warnings about objc Index'ed assignments in ARC.
1005  if (S.getLangOpts().ObjCAutoRefCount && InstanceBase) {
1006  S.checkRetainCycles(InstanceBase->getSourceExpr(), RHS);
1007  S.checkUnsafeExprAssigns(opcLoc, LHS, RHS);
1008  }
1009 
1010  return result;
1011 }
1012 
1013 /// Capture the base object of an Objective-C Index'ed expression.
1014 Expr *ObjCSubscriptOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
1015  assert(InstanceBase == nullptr);
1016 
1017  // Capture base expression in an OVE and rebuild the syntactic
1018  // form to use the OVE as its base expression.
1019  InstanceBase = capture(RefExpr->getBaseExpr());
1020  InstanceKey = capture(RefExpr->getKeyExpr());
1021 
1022  syntacticBase =
1023  Rebuilder(S, [=](Expr *, unsigned Idx) -> Expr * {
1024  switch (Idx) {
1025  case 0:
1026  return InstanceBase;
1027  case 1:
1028  return InstanceKey;
1029  default:
1030  llvm_unreachable("Unexpected index for ObjCSubscriptExpr");
1031  }
1032  }).rebuild(syntacticBase);
1033 
1034  return syntacticBase;
1035 }
1036 
1037 /// CheckSubscriptingKind - This routine decide what type
1038 /// of indexing represented by "FromE" is being done.
1041  // If the expression already has integral or enumeration type, we're golden.
1042  QualType T = FromE->getType();
1043  if (T->isIntegralOrEnumerationType())
1044  return OS_Array;
1045 
1046  // If we don't have a class type in C++, there's no way we can get an
1047  // expression of integral or enumeration type.
1048  const RecordType *RecordTy = T->getAs<RecordType>();
1049  if (!RecordTy &&
1051  // All other scalar cases are assumed to be dictionary indexing which
1052  // caller handles, with diagnostics if needed.
1053  return OS_Dictionary;
1054  if (!getLangOpts().CPlusPlus ||
1055  !RecordTy || RecordTy->isIncompleteType()) {
1056  // No indexing can be done. Issue diagnostics and quit.
1057  const Expr *IndexExpr = FromE->IgnoreParenImpCasts();
1058  if (isa<StringLiteral>(IndexExpr))
1059  Diag(FromE->getExprLoc(), diag::err_objc_subscript_pointer)
1060  << T << FixItHint::CreateInsertion(FromE->getExprLoc(), "@");
1061  else
1062  Diag(FromE->getExprLoc(), diag::err_objc_subscript_type_conversion)
1063  << T;
1064  return OS_Error;
1065  }
1066 
1067  // We must have a complete class type.
1068  if (RequireCompleteType(FromE->getExprLoc(), T,
1069  diag::err_objc_index_incomplete_class_type, FromE))
1070  return OS_Error;
1071 
1072  // Look for a conversion to an integral, enumeration type, or
1073  // objective-C pointer type.
1074  int NoIntegrals=0, NoObjCIdPointers=0;
1075  SmallVector<CXXConversionDecl *, 4> ConversionDecls;
1076 
1077  for (NamedDecl *D : cast<CXXRecordDecl>(RecordTy->getDecl())
1078  ->getVisibleConversionFunctions()) {
1079  if (CXXConversionDecl *Conversion =
1080  dyn_cast<CXXConversionDecl>(D->getUnderlyingDecl())) {
1081  QualType CT = Conversion->getConversionType().getNonReferenceType();
1082  if (CT->isIntegralOrEnumerationType()) {
1083  ++NoIntegrals;
1084  ConversionDecls.push_back(Conversion);
1085  }
1086  else if (CT->isObjCIdType() ||CT->isBlockPointerType()) {
1087  ++NoObjCIdPointers;
1088  ConversionDecls.push_back(Conversion);
1089  }
1090  }
1091  }
1092  if (NoIntegrals ==1 && NoObjCIdPointers == 0)
1093  return OS_Array;
1094  if (NoIntegrals == 0 && NoObjCIdPointers == 1)
1095  return OS_Dictionary;
1096  if (NoIntegrals == 0 && NoObjCIdPointers == 0) {
1097  // No conversion function was found. Issue diagnostic and return.
1098  Diag(FromE->getExprLoc(), diag::err_objc_subscript_type_conversion)
1099  << FromE->getType();
1100  return OS_Error;
1101  }
1102  Diag(FromE->getExprLoc(), diag::err_objc_multiple_subscript_type_conversion)
1103  << FromE->getType();
1104  for (unsigned int i = 0; i < ConversionDecls.size(); i++)
1105  Diag(ConversionDecls[i]->getLocation(), diag::not_conv_function_declared_at);
1106 
1107  return OS_Error;
1108 }
1109 
1110 /// CheckKeyForObjCARCConversion - This routine suggests bridge casting of CF
1111 /// objects used as dictionary subscript key objects.
1112 static void CheckKeyForObjCARCConversion(Sema &S, QualType ContainerT,
1113  Expr *Key) {
1114  if (ContainerT.isNull())
1115  return;
1116  // dictionary subscripting.
1117  // - (id)objectForKeyedSubscript:(id)key;
1118  IdentifierInfo *KeyIdents[] = {
1119  &S.Context.Idents.get("objectForKeyedSubscript")
1120  };
1121  Selector GetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
1122  ObjCMethodDecl *Getter = S.LookupMethodInObjectType(GetterSelector, ContainerT,
1123  true /*instance*/);
1124  if (!Getter)
1125  return;
1126  QualType T = Getter->parameters()[0]->getType();
1127  S.CheckObjCARCConversion(Key->getSourceRange(),
1129 }
1130 
1131 bool ObjCSubscriptOpBuilder::findAtIndexGetter() {
1132  if (AtIndexGetter)
1133  return true;
1134 
1135  Expr *BaseExpr = RefExpr->getBaseExpr();
1136  QualType BaseT = BaseExpr->getType();
1137 
1138  QualType ResultType;
1139  if (const ObjCObjectPointerType *PTy =
1140  BaseT->getAs<ObjCObjectPointerType>()) {
1141  ResultType = PTy->getPointeeType();
1142  }
1144  S.CheckSubscriptingKind(RefExpr->getKeyExpr());
1145  if (Res == Sema::OS_Error) {
1146  if (S.getLangOpts().ObjCAutoRefCount)
1147  CheckKeyForObjCARCConversion(S, ResultType,
1148  RefExpr->getKeyExpr());
1149  return false;
1150  }
1151  bool arrayRef = (Res == Sema::OS_Array);
1152 
1153  if (ResultType.isNull()) {
1154  S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_base_type)
1155  << BaseExpr->getType() << arrayRef;
1156  return false;
1157  }
1158  if (!arrayRef) {
1159  // dictionary subscripting.
1160  // - (id)objectForKeyedSubscript:(id)key;
1161  IdentifierInfo *KeyIdents[] = {
1162  &S.Context.Idents.get("objectForKeyedSubscript")
1163  };
1164  AtIndexGetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
1165  }
1166  else {
1167  // - (id)objectAtIndexedSubscript:(size_t)index;
1168  IdentifierInfo *KeyIdents[] = {
1169  &S.Context.Idents.get("objectAtIndexedSubscript")
1170  };
1171 
1172  AtIndexGetterSelector = S.Context.Selectors.getSelector(1, KeyIdents);
1173  }
1174 
1175  AtIndexGetter = S.LookupMethodInObjectType(AtIndexGetterSelector, ResultType,
1176  true /*instance*/);
1177  bool receiverIdType = (BaseT->isObjCIdType() ||
1178  BaseT->isObjCQualifiedIdType());
1179 
1180  if (!AtIndexGetter && S.getLangOpts().DebuggerObjCLiteral) {
1181  AtIndexGetter = ObjCMethodDecl::Create(S.Context, SourceLocation(),
1182  SourceLocation(), AtIndexGetterSelector,
1183  S.Context.getObjCIdType() /*ReturnType*/,
1184  nullptr /*TypeSourceInfo */,
1186  true /*Instance*/, false/*isVariadic*/,
1187  /*isPropertyAccessor=*/false,
1188  /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
1190  false);
1191  ParmVarDecl *Argument = ParmVarDecl::Create(S.Context, AtIndexGetter,
1193  arrayRef ? &S.Context.Idents.get("index")
1194  : &S.Context.Idents.get("key"),
1195  arrayRef ? S.Context.UnsignedLongTy
1196  : S.Context.getObjCIdType(),
1197  /*TInfo=*/nullptr,
1198  SC_None,
1199  nullptr);
1200  AtIndexGetter->setMethodParams(S.Context, Argument, None);
1201  }
1202 
1203  if (!AtIndexGetter) {
1204  if (!receiverIdType) {
1205  S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_method_not_found)
1206  << BaseExpr->getType() << 0 << arrayRef;
1207  return false;
1208  }
1209  AtIndexGetter =
1210  S.LookupInstanceMethodInGlobalPool(AtIndexGetterSelector,
1211  RefExpr->getSourceRange(),
1212  true);
1213  }
1214 
1215  if (AtIndexGetter) {
1216  QualType T = AtIndexGetter->parameters()[0]->getType();
1217  if ((arrayRef && !T->isIntegralOrEnumerationType()) ||
1218  (!arrayRef && !T->isObjCObjectPointerType())) {
1219  S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1220  arrayRef ? diag::err_objc_subscript_index_type
1221  : diag::err_objc_subscript_key_type) << T;
1222  S.Diag(AtIndexGetter->parameters()[0]->getLocation(),
1223  diag::note_parameter_type) << T;
1224  return false;
1225  }
1226  QualType R = AtIndexGetter->getReturnType();
1227  if (!R->isObjCObjectPointerType()) {
1228  S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1229  diag::err_objc_indexing_method_result_type) << R << arrayRef;
1230  S.Diag(AtIndexGetter->getLocation(), diag::note_method_declared_at) <<
1231  AtIndexGetter->getDeclName();
1232  }
1233  }
1234  return true;
1235 }
1236 
1237 bool ObjCSubscriptOpBuilder::findAtIndexSetter() {
1238  if (AtIndexSetter)
1239  return true;
1240 
1241  Expr *BaseExpr = RefExpr->getBaseExpr();
1242  QualType BaseT = BaseExpr->getType();
1243 
1244  QualType ResultType;
1245  if (const ObjCObjectPointerType *PTy =
1246  BaseT->getAs<ObjCObjectPointerType>()) {
1247  ResultType = PTy->getPointeeType();
1248  }
1249 
1251  S.CheckSubscriptingKind(RefExpr->getKeyExpr());
1252  if (Res == Sema::OS_Error) {
1253  if (S.getLangOpts().ObjCAutoRefCount)
1254  CheckKeyForObjCARCConversion(S, ResultType,
1255  RefExpr->getKeyExpr());
1256  return false;
1257  }
1258  bool arrayRef = (Res == Sema::OS_Array);
1259 
1260  if (ResultType.isNull()) {
1261  S.Diag(BaseExpr->getExprLoc(), diag::err_objc_subscript_base_type)
1262  << BaseExpr->getType() << arrayRef;
1263  return false;
1264  }
1265 
1266  if (!arrayRef) {
1267  // dictionary subscripting.
1268  // - (void)setObject:(id)object forKeyedSubscript:(id)key;
1269  IdentifierInfo *KeyIdents[] = {
1270  &S.Context.Idents.get("setObject"),
1271  &S.Context.Idents.get("forKeyedSubscript")
1272  };
1273  AtIndexSetterSelector = S.Context.Selectors.getSelector(2, KeyIdents);
1274  }
1275  else {
1276  // - (void)setObject:(id)object atIndexedSubscript:(NSInteger)index;
1277  IdentifierInfo *KeyIdents[] = {
1278  &S.Context.Idents.get("setObject"),
1279  &S.Context.Idents.get("atIndexedSubscript")
1280  };
1281  AtIndexSetterSelector = S.Context.Selectors.getSelector(2, KeyIdents);
1282  }
1283  AtIndexSetter = S.LookupMethodInObjectType(AtIndexSetterSelector, ResultType,
1284  true /*instance*/);
1285 
1286  bool receiverIdType = (BaseT->isObjCIdType() ||
1287  BaseT->isObjCQualifiedIdType());
1288 
1289  if (!AtIndexSetter && S.getLangOpts().DebuggerObjCLiteral) {
1290  TypeSourceInfo *ReturnTInfo = nullptr;
1291  QualType ReturnType = S.Context.VoidTy;
1292  AtIndexSetter = ObjCMethodDecl::Create(
1293  S.Context, SourceLocation(), SourceLocation(), AtIndexSetterSelector,
1294  ReturnType, ReturnTInfo, S.Context.getTranslationUnitDecl(),
1295  true /*Instance*/, false /*isVariadic*/,
1296  /*isPropertyAccessor=*/false,
1297  /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
1298  ObjCMethodDecl::Required, false);
1300  ParmVarDecl *object = ParmVarDecl::Create(S.Context, AtIndexSetter,
1302  &S.Context.Idents.get("object"),
1304  /*TInfo=*/nullptr,
1305  SC_None,
1306  nullptr);
1307  Params.push_back(object);
1308  ParmVarDecl *key = ParmVarDecl::Create(S.Context, AtIndexSetter,
1310  arrayRef ? &S.Context.Idents.get("index")
1311  : &S.Context.Idents.get("key"),
1312  arrayRef ? S.Context.UnsignedLongTy
1313  : S.Context.getObjCIdType(),
1314  /*TInfo=*/nullptr,
1315  SC_None,
1316  nullptr);
1317  Params.push_back(key);
1318  AtIndexSetter->setMethodParams(S.Context, Params, None);
1319  }
1320 
1321  if (!AtIndexSetter) {
1322  if (!receiverIdType) {
1323  S.Diag(BaseExpr->getExprLoc(),
1324  diag::err_objc_subscript_method_not_found)
1325  << BaseExpr->getType() << 1 << arrayRef;
1326  return false;
1327  }
1328  AtIndexSetter =
1329  S.LookupInstanceMethodInGlobalPool(AtIndexSetterSelector,
1330  RefExpr->getSourceRange(),
1331  true);
1332  }
1333 
1334  bool err = false;
1335  if (AtIndexSetter && arrayRef) {
1336  QualType T = AtIndexSetter->parameters()[1]->getType();
1337  if (!T->isIntegralOrEnumerationType()) {
1338  S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1339  diag::err_objc_subscript_index_type) << T;
1340  S.Diag(AtIndexSetter->parameters()[1]->getLocation(),
1341  diag::note_parameter_type) << T;
1342  err = true;
1343  }
1344  T = AtIndexSetter->parameters()[0]->getType();
1345  if (!T->isObjCObjectPointerType()) {
1346  S.Diag(RefExpr->getBaseExpr()->getExprLoc(),
1347  diag::err_objc_subscript_object_type) << T << arrayRef;
1348  S.Diag(AtIndexSetter->parameters()[0]->getLocation(),
1349  diag::note_parameter_type) << T;
1350  err = true;
1351  }
1352  }
1353  else if (AtIndexSetter && !arrayRef)
1354  for (unsigned i=0; i <2; i++) {
1355  QualType T = AtIndexSetter->parameters()[i]->getType();
1356  if (!T->isObjCObjectPointerType()) {
1357  if (i == 1)
1358  S.Diag(RefExpr->getKeyExpr()->getExprLoc(),
1359  diag::err_objc_subscript_key_type) << T;
1360  else
1361  S.Diag(RefExpr->getBaseExpr()->getExprLoc(),
1362  diag::err_objc_subscript_dic_object_type) << T;
1363  S.Diag(AtIndexSetter->parameters()[i]->getLocation(),
1364  diag::note_parameter_type) << T;
1365  err = true;
1366  }
1367  }
1368 
1369  return !err;
1370 }
1371 
1372 // Get the object at "Index" position in the container.
1373 // [BaseExpr objectAtIndexedSubscript : IndexExpr];
1374 ExprResult ObjCSubscriptOpBuilder::buildGet() {
1375  if (!findAtIndexGetter())
1376  return ExprError();
1377 
1378  QualType receiverType = InstanceBase->getType();
1379 
1380  // Build a message-send.
1381  ExprResult msg;
1382  Expr *Index = InstanceKey;
1383 
1384  // Arguments.
1385  Expr *args[] = { Index };
1386  assert(InstanceBase);
1387  if (AtIndexGetter)
1388  S.DiagnoseUseOfDecl(AtIndexGetter, GenericLoc);
1389  msg = S.BuildInstanceMessageImplicit(InstanceBase, receiverType,
1390  GenericLoc,
1391  AtIndexGetterSelector, AtIndexGetter,
1392  MultiExprArg(args, 1));
1393  return msg;
1394 }
1395 
1396 /// Store into the container the "op" object at "Index"'ed location
1397 /// by building this messaging expression:
1398 /// - (void)setObject:(id)object atIndexedSubscript:(NSInteger)index;
1399 /// \param captureSetValueAsResult If true, capture the actual
1400 /// value being set as the value of the property operation.
1401 ExprResult ObjCSubscriptOpBuilder::buildSet(Expr *op, SourceLocation opcLoc,
1402  bool captureSetValueAsResult) {
1403  if (!findAtIndexSetter())
1404  return ExprError();
1405  if (AtIndexSetter)
1406  S.DiagnoseUseOfDecl(AtIndexSetter, GenericLoc);
1407  QualType receiverType = InstanceBase->getType();
1408  Expr *Index = InstanceKey;
1409 
1410  // Arguments.
1411  Expr *args[] = { op, Index };
1412 
1413  // Build a message-send.
1414  ExprResult msg = S.BuildInstanceMessageImplicit(InstanceBase, receiverType,
1415  GenericLoc,
1416  AtIndexSetterSelector,
1417  AtIndexSetter,
1418  MultiExprArg(args, 2));
1419 
1420  if (!msg.isInvalid() && captureSetValueAsResult) {
1421  ObjCMessageExpr *msgExpr =
1422  cast<ObjCMessageExpr>(msg.get()->IgnoreImplicit());
1423  Expr *arg = msgExpr->getArg(0);
1424  if (CanCaptureValue(arg))
1425  msgExpr->setArg(0, captureValueAsResult(arg));
1426  }
1427 
1428  return msg;
1429 }
1430 
1431 //===----------------------------------------------------------------------===//
1432 // MSVC __declspec(property) references
1433 //===----------------------------------------------------------------------===//
1434 
1436 MSPropertyOpBuilder::getBaseMSProperty(MSPropertySubscriptExpr *E) {
1437  CallArgs.insert(CallArgs.begin(), E->getIdx());
1438  Expr *Base = E->getBase()->IgnoreParens();
1439  while (auto *MSPropSubscript = dyn_cast<MSPropertySubscriptExpr>(Base)) {
1440  CallArgs.insert(CallArgs.begin(), MSPropSubscript->getIdx());
1441  Base = MSPropSubscript->getBase()->IgnoreParens();
1442  }
1443  return cast<MSPropertyRefExpr>(Base);
1444 }
1445 
1446 Expr *MSPropertyOpBuilder::rebuildAndCaptureObject(Expr *syntacticBase) {
1447  InstanceBase = capture(RefExpr->getBaseExpr());
1448  std::for_each(CallArgs.begin(), CallArgs.end(),
1449  [this](Expr *&Arg) { Arg = capture(Arg); });
1450  syntacticBase = Rebuilder(S, [=](Expr *, unsigned Idx) -> Expr * {
1451  switch (Idx) {
1452  case 0:
1453  return InstanceBase;
1454  default:
1455  assert(Idx <= CallArgs.size());
1456  return CallArgs[Idx - 1];
1457  }
1458  }).rebuild(syntacticBase);
1459 
1460  return syntacticBase;
1461 }
1462 
1463 ExprResult MSPropertyOpBuilder::buildGet() {
1464  if (!RefExpr->getPropertyDecl()->hasGetter()) {
1465  S.Diag(RefExpr->getMemberLoc(), diag::err_no_accessor_for_property)
1466  << 0 /* getter */ << RefExpr->getPropertyDecl();
1467  return ExprError();
1468  }
1469 
1470  UnqualifiedId GetterName;
1471  IdentifierInfo *II = RefExpr->getPropertyDecl()->getGetterId();
1472  GetterName.setIdentifier(II, RefExpr->getMemberLoc());
1473  CXXScopeSpec SS;
1474  SS.Adopt(RefExpr->getQualifierLoc());
1475  ExprResult GetterExpr =
1476  S.ActOnMemberAccessExpr(S.getCurScope(), InstanceBase, SourceLocation(),
1477  RefExpr->isArrow() ? tok::arrow : tok::period, SS,
1478  SourceLocation(), GetterName, nullptr);
1479  if (GetterExpr.isInvalid()) {
1480  S.Diag(RefExpr->getMemberLoc(),
1481  diag::error_cannot_find_suitable_accessor) << 0 /* getter */
1482  << RefExpr->getPropertyDecl();
1483  return ExprError();
1484  }
1485 
1486  return S.ActOnCallExpr(S.getCurScope(), GetterExpr.get(),
1487  RefExpr->getSourceRange().getBegin(), CallArgs,
1488  RefExpr->getSourceRange().getEnd());
1489 }
1490 
1491 ExprResult MSPropertyOpBuilder::buildSet(Expr *op, SourceLocation sl,
1492  bool captureSetValueAsResult) {
1493  if (!RefExpr->getPropertyDecl()->hasSetter()) {
1494  S.Diag(RefExpr->getMemberLoc(), diag::err_no_accessor_for_property)
1495  << 1 /* setter */ << RefExpr->getPropertyDecl();
1496  return ExprError();
1497  }
1498 
1499  UnqualifiedId SetterName;
1500  IdentifierInfo *II = RefExpr->getPropertyDecl()->getSetterId();
1501  SetterName.setIdentifier(II, RefExpr->getMemberLoc());
1502  CXXScopeSpec SS;
1503  SS.Adopt(RefExpr->getQualifierLoc());
1504  ExprResult SetterExpr =
1505  S.ActOnMemberAccessExpr(S.getCurScope(), InstanceBase, SourceLocation(),
1506  RefExpr->isArrow() ? tok::arrow : tok::period, SS,
1507  SourceLocation(), SetterName, nullptr);
1508  if (SetterExpr.isInvalid()) {
1509  S.Diag(RefExpr->getMemberLoc(),
1510  diag::error_cannot_find_suitable_accessor) << 1 /* setter */
1511  << RefExpr->getPropertyDecl();
1512  return ExprError();
1513  }
1514 
1515  SmallVector<Expr*, 4> ArgExprs;
1516  ArgExprs.append(CallArgs.begin(), CallArgs.end());
1517  ArgExprs.push_back(op);
1518  return S.ActOnCallExpr(S.getCurScope(), SetterExpr.get(),
1519  RefExpr->getSourceRange().getBegin(), ArgExprs,
1520  op->getSourceRange().getEnd());
1521 }
1522 
1523 //===----------------------------------------------------------------------===//
1524 // General Sema routines.
1525 //===----------------------------------------------------------------------===//
1526 
1528  Expr *opaqueRef = E->IgnoreParens();
1529  if (ObjCPropertyRefExpr *refExpr
1530  = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1531  ObjCPropertyOpBuilder builder(*this, refExpr);
1532  return builder.buildRValueOperation(E);
1533  }
1534  else if (ObjCSubscriptRefExpr *refExpr
1535  = dyn_cast<ObjCSubscriptRefExpr>(opaqueRef)) {
1536  ObjCSubscriptOpBuilder builder(*this, refExpr);
1537  return builder.buildRValueOperation(E);
1538  } else if (MSPropertyRefExpr *refExpr
1539  = dyn_cast<MSPropertyRefExpr>(opaqueRef)) {
1540  MSPropertyOpBuilder builder(*this, refExpr);
1541  return builder.buildRValueOperation(E);
1542  } else if (MSPropertySubscriptExpr *RefExpr =
1543  dyn_cast<MSPropertySubscriptExpr>(opaqueRef)) {
1544  MSPropertyOpBuilder Builder(*this, RefExpr);
1545  return Builder.buildRValueOperation(E);
1546  } else {
1547  llvm_unreachable("unknown pseudo-object kind!");
1548  }
1549 }
1550 
1551 /// Check an increment or decrement of a pseudo-object expression.
1553  UnaryOperatorKind opcode, Expr *op) {
1554  // Do nothing if the operand is dependent.
1555  if (op->isTypeDependent())
1556  return new (Context) UnaryOperator(op, opcode, Context.DependentTy,
1557  VK_RValue, OK_Ordinary, opcLoc);
1558 
1559  assert(UnaryOperator::isIncrementDecrementOp(opcode));
1560  Expr *opaqueRef = op->IgnoreParens();
1561  if (ObjCPropertyRefExpr *refExpr
1562  = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1563  ObjCPropertyOpBuilder builder(*this, refExpr);
1564  return builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1565  } else if (isa<ObjCSubscriptRefExpr>(opaqueRef)) {
1566  Diag(opcLoc, diag::err_illegal_container_subscripting_op);
1567  return ExprError();
1568  } else if (MSPropertyRefExpr *refExpr
1569  = dyn_cast<MSPropertyRefExpr>(opaqueRef)) {
1570  MSPropertyOpBuilder builder(*this, refExpr);
1571  return builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1572  } else if (MSPropertySubscriptExpr *RefExpr
1573  = dyn_cast<MSPropertySubscriptExpr>(opaqueRef)) {
1574  MSPropertyOpBuilder Builder(*this, RefExpr);
1575  return Builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
1576  } else {
1577  llvm_unreachable("unknown pseudo-object kind!");
1578  }
1579 }
1580 
1582  BinaryOperatorKind opcode,
1583  Expr *LHS, Expr *RHS) {
1584  // Do nothing if either argument is dependent.
1585  if (LHS->isTypeDependent() || RHS->isTypeDependent())
1586  return new (Context) BinaryOperator(LHS, RHS, opcode, Context.DependentTy,
1587  VK_RValue, OK_Ordinary, opcLoc, false);
1588 
1589  // Filter out non-overload placeholder types in the RHS.
1590  if (RHS->getType()->isNonOverloadPlaceholderType()) {
1591  ExprResult result = CheckPlaceholderExpr(RHS);
1592  if (result.isInvalid()) return ExprError();
1593  RHS = result.get();
1594  }
1595 
1596  Expr *opaqueRef = LHS->IgnoreParens();
1597  if (ObjCPropertyRefExpr *refExpr
1598  = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
1599  ObjCPropertyOpBuilder builder(*this, refExpr);
1600  return builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1601  } else if (ObjCSubscriptRefExpr *refExpr
1602  = dyn_cast<ObjCSubscriptRefExpr>(opaqueRef)) {
1603  ObjCSubscriptOpBuilder builder(*this, refExpr);
1604  return builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1605  } else if (MSPropertyRefExpr *refExpr
1606  = dyn_cast<MSPropertyRefExpr>(opaqueRef)) {
1607  MSPropertyOpBuilder builder(*this, refExpr);
1608  return builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1609  } else if (MSPropertySubscriptExpr *RefExpr
1610  = dyn_cast<MSPropertySubscriptExpr>(opaqueRef)) {
1611  MSPropertyOpBuilder Builder(*this, RefExpr);
1612  return Builder.buildAssignmentOperation(S, opcLoc, opcode, LHS, RHS);
1613  } else {
1614  llvm_unreachable("unknown pseudo-object kind!");
1615  }
1616 }
1617 
1618 /// Given a pseudo-object reference, rebuild it without the opaque
1619 /// values. Basically, undo the behavior of rebuildAndCaptureObject.
1620 /// This should never operate in-place.
1622  return Rebuilder(S,
1623  [=](Expr *E, unsigned) -> Expr * {
1624  return cast<OpaqueValueExpr>(E)->getSourceExpr();
1625  })
1626  .rebuild(E);
1627 }
1628 
1629 /// Given a pseudo-object expression, recreate what it looks like
1630 /// syntactically without the attendant OpaqueValueExprs.
1631 ///
1632 /// This is a hack which should be removed when TreeTransform is
1633 /// capable of rebuilding a tree without stripping implicit
1634 /// operations.
1636  Expr *syntax = E->getSyntacticForm();
1637  if (UnaryOperator *uop = dyn_cast<UnaryOperator>(syntax)) {
1638  Expr *op = stripOpaqueValuesFromPseudoObjectRef(*this, uop->getSubExpr());
1639  return new (Context) UnaryOperator(op, uop->getOpcode(), uop->getType(),
1640  uop->getValueKind(), uop->getObjectKind(),
1641  uop->getOperatorLoc());
1642  } else if (CompoundAssignOperator *cop
1643  = dyn_cast<CompoundAssignOperator>(syntax)) {
1644  Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, cop->getLHS());
1645  Expr *rhs = cast<OpaqueValueExpr>(cop->getRHS())->getSourceExpr();
1646  return new (Context) CompoundAssignOperator(lhs, rhs, cop->getOpcode(),
1647  cop->getType(),
1648  cop->getValueKind(),
1649  cop->getObjectKind(),
1650  cop->getComputationLHSType(),
1651  cop->getComputationResultType(),
1652  cop->getOperatorLoc(), false);
1653  } else if (BinaryOperator *bop = dyn_cast<BinaryOperator>(syntax)) {
1654  Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, bop->getLHS());
1655  Expr *rhs = cast<OpaqueValueExpr>(bop->getRHS())->getSourceExpr();
1656  return new (Context) BinaryOperator(lhs, rhs, bop->getOpcode(),
1657  bop->getType(), bop->getValueKind(),
1658  bop->getObjectKind(),
1659  bop->getOperatorLoc(), false);
1660  } else {
1661  assert(syntax->hasPlaceholderType(BuiltinType::PseudoObject));
1662  return stripOpaqueValuesFromPseudoObjectRef(*this, syntax);
1663  }
1664 }
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
Definition: ExprObjC.h:539
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
Definition: Expr.h:407
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
bool isSelfExpr(Expr *RExpr)
Private Helper predicate to check for 'self'.
Scope * getCurScope() const
Retrieve the parser's current scope.
Definition: Sema.h:9197
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:169
Expr * getSyntacticForm()
Return the syntactic form of this expression, i.e.
Definition: Expr.h:4736
Smart pointer class that efficiently represents Objective-C method names.
bool isNonOverloadPlaceholderType() const
Test for a placeholder type other than Overload; see BuiltinType::isNonOverloadPlaceholderType.
Definition: Type.h:5540
SelectorTable & getSelectorTable()
Definition: Preprocessor.h:692
A (possibly-)qualified type.
Definition: Type.h:575
bool isObjCContainer() const
Definition: DeclBase.h:1237
bool isInvalid() const
Definition: Ownership.h:159
static Opcode getOpForCompoundAssignment(Opcode Opc)
Definition: Expr.h:3011
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.cpp:1043
DeclContext * getCurLexicalContext() const
Definition: Sema.h:9208
const LangOptions & getLangOpts() const
Definition: Sema.h:1041
ObjCMethodDecl * LookupMethodInObjectType(Selector Sel, QualType Ty, bool IsInstance)
LookupMethodInType - Look up a method in an ObjCObjectType.
ObjCSubscriptKind
Definition: Sema.h:2359
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
Definition: Expr.h:462
bool isRecordType() const
Definition: Type.h:5362
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1118
ObjCMethodDecl * getAtIndexMethodDecl() const
Definition: ExprObjC.h:813
AssignConvertType
AssignConvertType - All of the 'assignment' semantic checks return this enum to indicate whether the ...
Definition: Sema.h:8316
bool isVoidPointerType() const
Definition: Type.cpp:385
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1605
PtrTy get() const
Definition: Ownership.h:163
ObjCSubscriptRefExpr - used for array and dictionary subscripting.
Definition: ExprObjC.h:760
A container of type source information.
Definition: Decl.h:61
MS property subscript expression.
Definition: ExprCXX.h:712
bool isBlockPointerType() const
Definition: Type.h:5311
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Definition: DeclSpec.cpp:125
bool isExplicitProperty() const
Definition: ExprObjC.h:631
QualType substObjCMemberType(QualType objectType, const DeclContext *dc, ObjCSubstitutionContext context) const
Substitute type arguments from an object type for the Objective-C type parameters used in the subject...
Definition: Type.cpp:1244
DiagnosticsEngine & Diags
Definition: Sema.h:297
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:1793
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:113
static void CheckKeyForObjCARCConversion(Sema &S, QualType ContainerT, Expr *Key)
CheckKeyForObjCARCConversion - This routine suggests bridge casting of CF objects used as dictionary ...
ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *Input)
Definition: SemaExpr.cpp:11171
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1299
Defines the clang::Expr interface and subclasses for C++ expressions.
bool isPrefix() const
Definition: Expr.h:1698
QualType getType() const
Definition: DeclObjC.h:2497
ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false)
ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
Definition: SemaExpr.cpp:5002
One of these records is kept for each identifier that is lexed.
bool hasAttr() const
Definition: DeclBase.h:498
IdentifierInfo * getIdentifierInfoForSlot(unsigned argIndex) const
Retrieve the identifier at a given position in the selector.
ObjCInterfaceDecl * getClassReceiver() const
Definition: ExprObjC.h:696
ExprResult BuildClassMessageImplicit(QualType ReceiverType, bool isSuperReceiver, SourceLocation Loc, Selector Sel, ObjCMethodDecl *Method, MultiExprArg Args)
ObjCSubscriptKind CheckSubscriptingKind(Expr *FromE)
CheckSubscriptingKind - This routine decide what type of indexing represented by "FromE" is being don...
IdentifierTable & Idents
Definition: ASTContext.h:451
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:102
static ObjCMethodDecl * LookupMethodInReceiverType(Sema &S, Selector sel, const ObjCPropertyRefExpr *PRE)
Look up a method in the receiver type of an Objective-C property reference.
static Selector constructSetterSelector(IdentifierTable &Idents, SelectorTable &SelTable, const IdentifierInfo *Name)
Return the default setter selector for the given identifier.
BinaryOperatorKind
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:874
Selector getNullarySelector(IdentifierInfo *ID)
bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics...
Definition: SemaExpr.cpp:324
static Expr * stripOpaqueValuesFromPseudoObjectRef(Sema &S, Expr *E)
Given a pseudo-object reference, rebuild it without the opaque values.
bool isSuperReceiver() const
Definition: ExprObjC.h:700
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2875
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:146
RecordDecl * getDecl() const
Definition: Type.h:3553
Selector getSetterName() const
Definition: DeclObjC.h:2562
Expr * getBaseExpr() const
Definition: ExprCXX.h:692
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:38
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:1886
Preprocessor & PP
Definition: Sema.h:294
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Definition: Expr.cpp:720
AssignConvertType CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, bool Diagnose=true, bool DiagnoseCFAudited=false, bool ConvertRHS=true)
Definition: SemaExpr.cpp:7432
An ordinary object is located at an address in memory.
Definition: Specifiers.h:118
const Expr * getBase() const
Definition: ExprObjC.h:682
Represents an ObjC class declaration.
Definition: DeclObjC.h:853
ObjCMethodDecl * setAtIndexMethodDecl() const
Definition: ExprObjC.h:817
PropertyAttributeKind getPropertyAttributes() const
Definition: DeclObjC.h:2508
MSPropertyDecl * getPropertyDecl() const
Definition: ExprCXX.h:693
ExprResult checkPseudoObjectIncDec(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opcode, Expr *Op)
Check an increment or decrement of a pseudo-object expression.
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:259
bool isAssignmentOp() const
Definition: Expr.h:3003
SourceLocation getMemberLoc() const
Definition: ExprCXX.h:695
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:980
NestedNameSpecifierLoc getQualifierLoc() const
Definition: ExprCXX.h:696
ASTContext * Context
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:415
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl...
Expr - This represents one expression.
Definition: Expr.h:104
StringRef getName() const
Return the actual identifier string.
static ObjCMethodDecl * Create(ASTContext &C, SourceLocation beginLoc, SourceLocation endLoc, Selector SelInfo, QualType T, TypeSourceInfo *ReturnTInfo, DeclContext *contextDecl, bool isInstance=true, bool isVariadic=false, bool isPropertyAccessor=false, bool isImplicitlyDeclared=false, bool isDefined=false, ImplementationControl impControl=None, bool HasRelatedResultType=false)
Definition: DeclObjC.cpp:722
CK_BitCast - A conversion which causes a bit pattern of one type to be reinterpreted as a bit pattern...
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:875
Defines the clang::Preprocessor interface.
ObjCMethodDecl * getImplicitPropertyGetter() const
Definition: ExprObjC.h:638
DeclContext * getDeclContext()
Definition: DeclBase.h:393
Decl * getNonClosureAncestor()
Find the nearest non-closure ancestor of this context, i.e.
Definition: DeclBase.cpp:819
bool DiagnoseAssignmentResult(AssignConvertType ConvTy, SourceLocation Loc, QualType DstType, QualType SrcType, Expr *SrcExpr, AssignmentAction Action, bool *Complained=nullptr)
DiagnoseAssignmentResult - Emit a diagnostic, if required, for the assignment conversion type specifi...
Definition: SemaExpr.cpp:12029
bool isObjCIdType() const
Definition: Type.h:5401
SourceLocation getLocation() const
Definition: ExprObjC.h:689
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1751
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1593
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:860
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1654
A member reference to an MSPropertyDecl.
Definition: ExprCXX.h:647
bool isGLValue() const
Definition: Expr.h:249
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2392
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: ExprObjC.h:1290
ArrayRef< ParmVarDecl * > parameters() const
Definition: DeclObjC.h:376
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:840
SelectorTable & Selectors
Definition: ASTContext.h:452
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:5596
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:145
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:4692
SourceLocation getRBracket() const
Definition: ExprObjC.h:795
Encodes a location in the source.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
void checkRetainCycles(ObjCMessageExpr *msg)
checkRetainCycles - Check whether an Objective-C message send might create an obvious retain cycle...
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:690
CanQualType VoidTy
Definition: ASTContext.h:881
bool isPropertyAccessor() const
Definition: DeclObjC.h:426
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:2416
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:5706
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
Definition: Expr.h:164
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:1167
#define exp(__x)
Definition: tgmath.h:438
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:645
bool isObjectReceiver() const
Definition: ExprObjC.h:699
MutableArrayRef< Expr * > MultiExprArg
Definition: Ownership.h:261
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:193
SourceLocation getRBracketLoc() const
Definition: ExprCXX.h:747
CompoundAssignOperator - For compound assignments (e.g.
Definition: Expr.h:3070
Represents a C11 generic selection.
Definition: Expr.h:4426
QualType getType() const
Definition: Expr.h:125
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Definition: Decl.cpp:2334
void recordUseOfEvaluatedWeak(const ExprT *E, bool IsRead=true)
Definition: Sema.h:1184
Expr * recreateSyntacticForm(PseudoObjectExpr *E)
Given a pseudo-object expression, recreate what it looks like syntactically without the attendant Opa...
ExprResult checkPseudoObjectAssignment(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opcode, Expr *LHS, Expr *RHS)
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_RValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
Definition: Sema.cpp:369
bool isClassReceiver() const
Definition: ExprObjC.h:701
Selector getGetterName() const
Definition: DeclObjC.h:2559
Selector getSelector() const
Definition: DeclObjC.h:328
detail::InMemoryDirectory::const_iterator E
ExprResult ActOnMemberAccessExpr(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Member, Decl *ObjCImpDecl)
The main callback when the parser finds something like expression .
bool isLValueReferenceType() const
Definition: Type.h:5317
static PseudoObjectExpr * Create(const ASTContext &Context, Expr *syntactic, ArrayRef< Expr * > semantic, unsigned resultIndex)
Definition: Expr.cpp:3876
Expr * getBaseExpr() const
Definition: ExprObjC.h:807
Expr * IgnoreParenImpCasts() LLVM_READONLY
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
Definition: Expr.cpp:2551
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:4836
ExprResult checkPseudoObjectRValue(Expr *E)
void markSafeWeakUse(const Expr *E)
Record that a given expression is a "safe" access of a weak object (e.g.
Definition: ScopeInfo.cpp:160
Represents a pointer to an Objective C object.
Definition: Type.h:4821
static LLVM_READONLY bool isLowercase(unsigned char c)
Return true if this character is a lowercase ASCII letter: [a-z].
Definition: CharInfo.h:100
ObjCMethodDecl * LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R, bool receiverIdOrClass=false)
LookupInstanceMethodInGlobalPool - Returns the method and warns if there are multiple signatures...
Definition: Sema.h:3197
bool isDecrementOp() const
Definition: Expr.h:1711
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3544
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5675
Decl::Kind getDeclKind() const
Definition: DeclBase.h:1194
CanQualType UnsignedLongTy
Definition: ASTContext.h:890
Selector getSelector(unsigned NumArgs, IdentifierInfo **IIV)
Can create any sort of selector.
CanQualType DependentTy
Definition: ASTContext.h:896
bool isObjCQualifiedIdType() const
Definition: Type.h:5391
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1522
bool isPostfix() const
Definition: Expr.h:1699
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:78
QualType getSuperReceiverType() const
Definition: ExprObjC.h:692
Expr * getKeyExpr() const
Definition: ExprObjC.h:810
bool isIncrementOp() const
Definition: Expr.h:1704
ObjCPropertyDecl * getExplicitProperty() const
Definition: ExprObjC.h:633
An implicit conversion.
Definition: Sema.h:8199
Reading or writing from this object requires a barrier call.
Definition: Type.h:147
bool isObjCClassType() const
True if this is equivalent to the 'Class' type, i.e.
Definition: Type.h:4888
Represents a C++ struct/union/class.
Definition: DeclCXX.h:285
BoundNodesTreeBuilder *const Builder
bool isObjCObjectPointerType() const
Definition: Type.h:5377
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:3525
The parameter type of a method or function.
static LLVM_READONLY char toLowercase(char c)
Converts the given ASCII character to its lowercase equivalent.
Definition: CharInfo.h:165
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:307
ExprResult BuildInstanceMessageImplicit(Expr *Receiver, QualType ReceiverType, SourceLocation Loc, Selector Sel, ObjCMethodDecl *Method, MultiExprArg Args)
ExprResult ExprError()
Definition: Ownership.h:267
bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD, ObjCMethodDecl *Getter, SourceLocation Loc)
CanQualType IntTy
Definition: ASTContext.h:889
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:400
void checkUnsafeExprAssigns(SourceLocation Loc, Expr *LHS, Expr *RHS)
checkUnsafeExprAssigns - Check whether +1 expr is being assigned to weak/__unsafe_unretained expressi...
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:106
static LLVM_READONLY char toUppercase(char c)
Converts the given ASCII character to its uppercase equivalent.
Definition: CharInfo.h:174
SourceLocation getLocation() const
Definition: DeclBase.h:384
ASTContext & Context
Definition: Sema.h:295
NamedDecl - This represents a decl with a name.
Definition: Decl.h:145
void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)
Specify that this unqualified-id was parsed as an identifier.
Definition: DeclSpec.h:978
ARCConversionResult CheckObjCARCConversion(SourceRange castRange, QualType castType, Expr *&op, CheckedConversionKind CCK, bool Diagnose=true, bool DiagnoseCFAudited=false, BinaryOperatorKind Opc=BO_PtrMemD)
Checks for invalid conversions and casts between retainable pointers and other pointer kinds...
bool isArrow() const
Definition: ExprCXX.h:694
bool isIncrementDecrementOp() const
Definition: Expr.h:1716
ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
Definition: SemaExpr.cpp:10876
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:642
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
Definition: ExprObjC.h:1299
ObjCMethodDecl * getImplicitPropertySetter() const
Definition: ExprObjC.h:643
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2433