clang  8.0.0svn
ExprObjC.h
Go to the documentation of this file.
1 //===- ExprObjC.h - Classes for representing ObjC expressions ---*- C++ -*-===//
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 defines the ExprObjC interface and subclasses.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_AST_EXPROBJC_H
15 #define LLVM_CLANG_AST_EXPROBJC_H
16 
17 #include "clang/AST/Decl.h"
18 #include "clang/AST/DeclObjC.h"
19 #include "clang/AST/Expr.h"
22 #include "clang/AST/Stmt.h"
23 #include "clang/AST/Type.h"
25 #include "clang/Basic/LLVM.h"
27 #include "clang/Basic/Specifiers.h"
28 #include "llvm/ADT/ArrayRef.h"
29 #include "llvm/ADT/None.h"
30 #include "llvm/ADT/Optional.h"
31 #include "llvm/ADT/PointerIntPair.h"
32 #include "llvm/ADT/PointerUnion.h"
33 #include "llvm/ADT/StringRef.h"
34 #include "llvm/ADT/iterator_range.h"
35 #include "llvm/Support/Casting.h"
36 #include "llvm/Support/Compiler.h"
37 #include "llvm/Support/TrailingObjects.h"
38 #include "llvm/Support/VersionTuple.h"
39 #include "llvm/Support/type_traits.h"
40 #include <cassert>
41 #include <cstddef>
42 #include <cstdint>
43 
44 namespace clang {
45 
46 class ASTContext;
47 class CXXBaseSpecifier;
48 
49 /// ObjCStringLiteral, used for Objective-C string literals
50 /// i.e. @"foo".
51 class ObjCStringLiteral : public Expr {
52  Stmt *String;
53  SourceLocation AtLoc;
54 
55 public:
57  : Expr(ObjCStringLiteralClass, T, VK_RValue, OK_Ordinary, false, false,
58  false, false),
59  String(SL), AtLoc(L) {}
60  explicit ObjCStringLiteral(EmptyShell Empty)
61  : Expr(ObjCStringLiteralClass, Empty) {}
62 
63  StringLiteral *getString() { return cast<StringLiteral>(String); }
64  const StringLiteral *getString() const { return cast<StringLiteral>(String); }
65  void setString(StringLiteral *S) { String = S; }
66 
67  SourceLocation getAtLoc() const { return AtLoc; }
68  void setAtLoc(SourceLocation L) { AtLoc = L; }
69 
70  SourceLocation getBeginLoc() const LLVM_READONLY { return AtLoc; }
71  SourceLocation getEndLoc() const LLVM_READONLY { return String->getEndLoc(); }
72 
73  // Iterators
74  child_range children() { return child_range(&String, &String+1); }
75 
76  static bool classof(const Stmt *T) {
77  return T->getStmtClass() == ObjCStringLiteralClass;
78  }
79 };
80 
81 /// ObjCBoolLiteralExpr - Objective-C Boolean Literal.
82 class ObjCBoolLiteralExpr : public Expr {
83  bool Value;
84  SourceLocation Loc;
85 
86 public:
88  : Expr(ObjCBoolLiteralExprClass, Ty, VK_RValue, OK_Ordinary, false, false,
89  false, false),
90  Value(val), Loc(l) {}
92  : Expr(ObjCBoolLiteralExprClass, Empty) {}
93 
94  bool getValue() const { return Value; }
95  void setValue(bool V) { Value = V; }
96 
97  SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
98  SourceLocation getEndLoc() const LLVM_READONLY { return Loc; }
99 
100  SourceLocation getLocation() const { return Loc; }
101  void setLocation(SourceLocation L) { Loc = L; }
102 
103  // Iterators
106  }
107 
108  static bool classof(const Stmt *T) {
109  return T->getStmtClass() == ObjCBoolLiteralExprClass;
110  }
111 };
112 
113 /// ObjCBoxedExpr - used for generalized expression boxing.
114 /// as in: @(strdup("hello world")), @(random()) or @(view.frame)
115 /// Also used for boxing non-parenthesized numeric literals;
116 /// as in: @42 or \@true (c++/objc++) or \@__objc_yes (c/objc).
117 class ObjCBoxedExpr : public Expr {
118  Stmt *SubExpr;
119  ObjCMethodDecl *BoxingMethod;
120  SourceRange Range;
121 
122 public:
123  friend class ASTStmtReader;
124 
126  SourceRange R)
127  : Expr(ObjCBoxedExprClass, T, VK_RValue, OK_Ordinary,
131  SubExpr(E), BoxingMethod(method), Range(R) {}
132  explicit ObjCBoxedExpr(EmptyShell Empty)
133  : Expr(ObjCBoxedExprClass, Empty) {}
134 
135  Expr *getSubExpr() { return cast<Expr>(SubExpr); }
136  const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
137 
139  return BoxingMethod;
140  }
141 
142  SourceLocation getAtLoc() const { return Range.getBegin(); }
143 
144  SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); }
145  SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); }
146 
147  SourceRange getSourceRange() const LLVM_READONLY {
148  return Range;
149  }
150 
151  // Iterators
152  child_range children() { return child_range(&SubExpr, &SubExpr+1); }
153 
155 
157  return reinterpret_cast<Stmt const * const*>(&SubExpr);
158  }
159 
161  return reinterpret_cast<Stmt const * const*>(&SubExpr + 1);
162  }
163 
164  static bool classof(const Stmt *T) {
165  return T->getStmtClass() == ObjCBoxedExprClass;
166  }
167 };
168 
169 /// ObjCArrayLiteral - used for objective-c array containers; as in:
170 /// @[@"Hello", NSApp, [NSNumber numberWithInt:42]];
171 class ObjCArrayLiteral final
172  : public Expr,
173  private llvm::TrailingObjects<ObjCArrayLiteral, Expr *> {
174  unsigned NumElements;
175  SourceRange Range;
176  ObjCMethodDecl *ArrayWithObjectsMethod;
177 
179  QualType T, ObjCMethodDecl * Method,
180  SourceRange SR);
181 
182  explicit ObjCArrayLiteral(EmptyShell Empty, unsigned NumElements)
183  : Expr(ObjCArrayLiteralClass, Empty), NumElements(NumElements) {}
184 
185 public:
186  friend class ASTStmtReader;
188 
189  static ObjCArrayLiteral *Create(const ASTContext &C,
190  ArrayRef<Expr *> Elements,
191  QualType T, ObjCMethodDecl * Method,
192  SourceRange SR);
193 
194  static ObjCArrayLiteral *CreateEmpty(const ASTContext &C,
195  unsigned NumElements);
196 
197  SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); }
198  SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); }
199  SourceRange getSourceRange() const LLVM_READONLY { return Range; }
200 
201  /// Retrieve elements of array of literals.
202  Expr **getElements() { return getTrailingObjects<Expr *>(); }
203 
204  /// Retrieve elements of array of literals.
205  const Expr * const *getElements() const {
206  return getTrailingObjects<Expr *>();
207  }
208 
209  /// getNumElements - Return number of elements of objective-c array literal.
210  unsigned getNumElements() const { return NumElements; }
211 
212  /// getElement - Return the Element at the specified index.
213  Expr *getElement(unsigned Index) {
214  assert((Index < NumElements) && "Arg access out of range!");
215  return getElements()[Index];
216  }
217  const Expr *getElement(unsigned Index) const {
218  assert((Index < NumElements) && "Arg access out of range!");
219  return getElements()[Index];
220  }
221 
223  return ArrayWithObjectsMethod;
224  }
225 
226  // Iterators
228  return child_range(reinterpret_cast<Stmt **>(getElements()),
229  reinterpret_cast<Stmt **>(getElements()) + NumElements);
230  }
231 
232  static bool classof(const Stmt *T) {
233  return T->getStmtClass() == ObjCArrayLiteralClass;
234  }
235 };
236 
237 /// An element in an Objective-C dictionary literal.
238 ///
240  /// The key for the dictionary element.
242 
243  /// The value of the dictionary element.
245 
246  /// The location of the ellipsis, if this is a pack expansion.
248 
249  /// The number of elements this pack expansion will expand to, if
250  /// this is a pack expansion and is known.
252 
253  /// Determines whether this dictionary element is a pack expansion.
254  bool isPackExpansion() const { return EllipsisLoc.isValid(); }
255 };
256 
257 } // namespace clang
258 
259 namespace llvm {
260 
261 template <> struct isPodLike<clang::ObjCDictionaryElement> : std::true_type {};
262 
263 } // namespace llvm
264 
265 namespace clang {
266 
267 /// Internal struct for storing Key/value pair.
271 };
272 
273 /// Internal struct to describes an element that is a pack
274 /// expansion, used if any of the elements in the dictionary literal
275 /// are pack expansions.
277  /// The location of the ellipsis, if this element is a pack
278  /// expansion.
280 
281  /// If non-zero, the number of elements that this pack
282  /// expansion will expand to (+1).
284 };
285 
286 /// ObjCDictionaryLiteral - AST node to represent objective-c dictionary
287 /// literals; as in: @{@"name" : NSUserName(), @"date" : [NSDate date] };
289  : public Expr,
290  private llvm::TrailingObjects<ObjCDictionaryLiteral,
291  ObjCDictionaryLiteral_KeyValuePair,
292  ObjCDictionaryLiteral_ExpansionData> {
293  /// The number of elements in this dictionary literal.
294  unsigned NumElements : 31;
295 
296  /// Determine whether this dictionary literal has any pack expansions.
297  ///
298  /// If the dictionary literal has pack expansions, then there will
299  /// be an array of pack expansion data following the array of
300  /// key/value pairs, which provide the locations of the ellipses (if
301  /// any) and number of elements in the expansion (if known). If
302  /// there are no pack expansions, we optimize away this storage.
303  unsigned HasPackExpansions : 1;
304 
305  SourceRange Range;
306  ObjCMethodDecl *DictWithObjectsMethod;
307 
310 
312  bool HasPackExpansions,
313  QualType T, ObjCMethodDecl *method,
314  SourceRange SR);
315 
316  explicit ObjCDictionaryLiteral(EmptyShell Empty, unsigned NumElements,
317  bool HasPackExpansions)
318  : Expr(ObjCDictionaryLiteralClass, Empty), NumElements(NumElements),
319  HasPackExpansions(HasPackExpansions) {}
320 
321  size_t numTrailingObjects(OverloadToken<KeyValuePair>) const {
322  return NumElements;
323  }
324 
325 public:
326  friend class ASTStmtReader;
327  friend class ASTStmtWriter;
329 
330  static ObjCDictionaryLiteral *Create(const ASTContext &C,
332  bool HasPackExpansions,
333  QualType T, ObjCMethodDecl *method,
334  SourceRange SR);
335 
337  unsigned NumElements,
338  bool HasPackExpansions);
339 
340  /// getNumElements - Return number of elements of objective-c dictionary
341  /// literal.
342  unsigned getNumElements() const { return NumElements; }
343 
345  assert((Index < NumElements) && "Arg access out of range!");
346  const KeyValuePair &KV = getTrailingObjects<KeyValuePair>()[Index];
348  if (HasPackExpansions) {
349  const ExpansionData &Expansion =
350  getTrailingObjects<ExpansionData>()[Index];
351  Result.EllipsisLoc = Expansion.EllipsisLoc;
352  if (Expansion.NumExpansionsPlusOne > 0)
353  Result.NumExpansions = Expansion.NumExpansionsPlusOne - 1;
354  }
355  return Result;
356  }
357 
359  return DictWithObjectsMethod;
360  }
361 
362  SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); }
363  SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); }
364  SourceRange getSourceRange() const LLVM_READONLY { return Range; }
365 
366  // Iterators
368  // Note: we're taking advantage of the layout of the KeyValuePair struct
369  // here. If that struct changes, this code will need to change as well.
370  static_assert(sizeof(KeyValuePair) == sizeof(Stmt *) * 2,
371  "KeyValuePair is expected size");
372  return child_range(
373  reinterpret_cast<Stmt **>(getTrailingObjects<KeyValuePair>()),
374  reinterpret_cast<Stmt **>(getTrailingObjects<KeyValuePair>()) +
375  NumElements * 2);
376  }
377 
378  static bool classof(const Stmt *T) {
379  return T->getStmtClass() == ObjCDictionaryLiteralClass;
380  }
381 };
382 
383 /// ObjCEncodeExpr, used for \@encode in Objective-C. \@encode has the same
384 /// type and behavior as StringLiteral except that the string initializer is
385 /// obtained from ASTContext with the encoding type as an argument.
386 class ObjCEncodeExpr : public Expr {
387  TypeSourceInfo *EncodedType;
388  SourceLocation AtLoc, RParenLoc;
389 
390 public:
393  : Expr(ObjCEncodeExprClass, T, VK_LValue, OK_Ordinary,
394  EncodedType->getType()->isDependentType(),
395  EncodedType->getType()->isDependentType(),
396  EncodedType->getType()->isInstantiationDependentType(),
397  EncodedType->getType()->containsUnexpandedParameterPack()),
398  EncodedType(EncodedType), AtLoc(at), RParenLoc(rp) {}
399 
400  explicit ObjCEncodeExpr(EmptyShell Empty) : Expr(ObjCEncodeExprClass, Empty){}
401 
402  SourceLocation getAtLoc() const { return AtLoc; }
403  void setAtLoc(SourceLocation L) { AtLoc = L; }
404  SourceLocation getRParenLoc() const { return RParenLoc; }
405  void setRParenLoc(SourceLocation L) { RParenLoc = L; }
406 
407  QualType getEncodedType() const { return EncodedType->getType(); }
408 
409  TypeSourceInfo *getEncodedTypeSourceInfo() const { return EncodedType; }
410 
412  EncodedType = EncType;
413  }
414 
415  SourceLocation getBeginLoc() const LLVM_READONLY { return AtLoc; }
416  SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
417 
418  // Iterators
421  }
422 
423  static bool classof(const Stmt *T) {
424  return T->getStmtClass() == ObjCEncodeExprClass;
425  }
426 };
427 
428 /// ObjCSelectorExpr used for \@selector in Objective-C.
429 class ObjCSelectorExpr : public Expr {
430  Selector SelName;
431  SourceLocation AtLoc, RParenLoc;
432 
433 public:
436  : Expr(ObjCSelectorExprClass, T, VK_RValue, OK_Ordinary, false, false,
437  false, false),
438  SelName(selInfo), AtLoc(at), RParenLoc(rp) {}
439  explicit ObjCSelectorExpr(EmptyShell Empty)
440  : Expr(ObjCSelectorExprClass, Empty) {}
441 
442  Selector getSelector() const { return SelName; }
443  void setSelector(Selector S) { SelName = S; }
444 
445  SourceLocation getAtLoc() const { return AtLoc; }
446  SourceLocation getRParenLoc() const { return RParenLoc; }
447  void setAtLoc(SourceLocation L) { AtLoc = L; }
448  void setRParenLoc(SourceLocation L) { RParenLoc = L; }
449 
450  SourceLocation getBeginLoc() const LLVM_READONLY { return AtLoc; }
451  SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
452 
453  /// getNumArgs - Return the number of actual arguments to this call.
454  unsigned getNumArgs() const { return SelName.getNumArgs(); }
455 
456  // Iterators
459  }
460 
461  static bool classof(const Stmt *T) {
462  return T->getStmtClass() == ObjCSelectorExprClass;
463  }
464 };
465 
466 /// ObjCProtocolExpr used for protocol expression in Objective-C.
467 ///
468 /// This is used as: \@protocol(foo), as in:
469 /// \code
470 /// [obj conformsToProtocol:@protocol(foo)]
471 /// \endcode
472 ///
473 /// The return type is "Protocol*".
474 class ObjCProtocolExpr : public Expr {
475  ObjCProtocolDecl *TheProtocol;
476  SourceLocation AtLoc, ProtoLoc, RParenLoc;
477 
478 public:
479  friend class ASTStmtReader;
480  friend class ASTStmtWriter;
481 
484  : Expr(ObjCProtocolExprClass, T, VK_RValue, OK_Ordinary, false, false,
485  false, false),
486  TheProtocol(protocol), AtLoc(at), ProtoLoc(protoLoc), RParenLoc(rp) {}
487  explicit ObjCProtocolExpr(EmptyShell Empty)
488  : Expr(ObjCProtocolExprClass, Empty) {}
489 
490  ObjCProtocolDecl *getProtocol() const { return TheProtocol; }
491  void setProtocol(ObjCProtocolDecl *P) { TheProtocol = P; }
492 
493  SourceLocation getProtocolIdLoc() const { return ProtoLoc; }
494  SourceLocation getAtLoc() const { return AtLoc; }
495  SourceLocation getRParenLoc() const { return RParenLoc; }
496  void setAtLoc(SourceLocation L) { AtLoc = L; }
497  void setRParenLoc(SourceLocation L) { RParenLoc = L; }
498 
499  SourceLocation getBeginLoc() const LLVM_READONLY { return AtLoc; }
500  SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
501 
502  // Iterators
505  }
506 
507  static bool classof(const Stmt *T) {
508  return T->getStmtClass() == ObjCProtocolExprClass;
509  }
510 };
511 
512 /// ObjCIvarRefExpr - A reference to an ObjC instance variable.
513 class ObjCIvarRefExpr : public Expr {
514  ObjCIvarDecl *D;
515  Stmt *Base;
516  SourceLocation Loc;
517 
518  /// OpLoc - This is the location of '.' or '->'
519  SourceLocation OpLoc;
520 
521  // True if this is "X->F", false if this is "X.F".
522  bool IsArrow : 1;
523 
524  // True if ivar reference has no base (self assumed).
525  bool IsFreeIvar : 1;
526 
527 public:
530  Expr *base,
531  bool arrow = false, bool freeIvar = false)
532  : Expr(ObjCIvarRefExprClass, t, VK_LValue,
533  d->isBitField() ? OK_BitField : OK_Ordinary,
534  /*TypeDependent=*/false, base->isValueDependent(),
535  base->isInstantiationDependent(),
537  D(d), Base(base), Loc(l), OpLoc(oploc), IsArrow(arrow),
538  IsFreeIvar(freeIvar) {}
539 
540  explicit ObjCIvarRefExpr(EmptyShell Empty)
541  : Expr(ObjCIvarRefExprClass, Empty) {}
542 
543  ObjCIvarDecl *getDecl() { return D; }
544  const ObjCIvarDecl *getDecl() const { return D; }
545  void setDecl(ObjCIvarDecl *d) { D = d; }
546 
547  const Expr *getBase() const { return cast<Expr>(Base); }
548  Expr *getBase() { return cast<Expr>(Base); }
549  void setBase(Expr * base) { Base = base; }
550 
551  bool isArrow() const { return IsArrow; }
552  bool isFreeIvar() const { return IsFreeIvar; }
553  void setIsArrow(bool A) { IsArrow = A; }
554  void setIsFreeIvar(bool A) { IsFreeIvar = A; }
555 
556  SourceLocation getLocation() const { return Loc; }
557  void setLocation(SourceLocation L) { Loc = L; }
558 
559  SourceLocation getBeginLoc() const LLVM_READONLY {
560  return isFreeIvar() ? Loc : getBase()->getBeginLoc();
561  }
562  SourceLocation getEndLoc() const LLVM_READONLY { return Loc; }
563 
564  SourceLocation getOpLoc() const { return OpLoc; }
565  void setOpLoc(SourceLocation L) { OpLoc = L; }
566 
567  // Iterators
568  child_range children() { return child_range(&Base, &Base+1); }
569 
570  static bool classof(const Stmt *T) {
571  return T->getStmtClass() == ObjCIvarRefExprClass;
572  }
573 };
574 
575 /// ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC
576 /// property.
577 class ObjCPropertyRefExpr : public Expr {
578 private:
579  /// If the bool is true, this is an implicit property reference; the
580  /// pointer is an (optional) ObjCMethodDecl and Setter may be set.
581  /// if the bool is false, this is an explicit property reference;
582  /// the pointer is an ObjCPropertyDecl and Setter is always null.
583  llvm::PointerIntPair<NamedDecl *, 1, bool> PropertyOrGetter;
584 
585  /// Indicates whether the property reference will result in a message
586  /// to the getter, the setter, or both.
587  /// This applies to both implicit and explicit property references.
588  enum MethodRefFlags {
589  MethodRef_None = 0,
590  MethodRef_Getter = 0x1,
591  MethodRef_Setter = 0x2
592  };
593 
594  /// Contains the Setter method pointer and MethodRefFlags bit flags.
595  llvm::PointerIntPair<ObjCMethodDecl *, 2, unsigned> SetterAndMethodRefFlags;
596 
597  // FIXME: Maybe we should store the property identifier here,
598  // because it's not rederivable from the other data when there's an
599  // implicit property with no getter (because the 'foo' -> 'setFoo:'
600  // transformation is lossy on the first character).
601 
602  SourceLocation IdLoc;
603 
604  /// When the receiver in property access is 'super', this is
605  /// the location of the 'super' keyword. When it's an interface,
606  /// this is that interface.
607  SourceLocation ReceiverLoc;
608  llvm::PointerUnion3<Stmt *, const Type *, ObjCInterfaceDecl *> Receiver;
609 
610 public:
613  SourceLocation l, Expr *base)
614  : Expr(ObjCPropertyRefExprClass, t, VK, OK,
615  /*TypeDependent=*/false, base->isValueDependent(),
616  base->isInstantiationDependent(),
618  PropertyOrGetter(PD, false), IdLoc(l), Receiver(base) {
619  assert(t->isSpecificPlaceholderType(BuiltinType::PseudoObject));
620  }
621 
625  : Expr(ObjCPropertyRefExprClass, t, VK, OK,
626  /*TypeDependent=*/false, false, st->isInstantiationDependentType(),
628  PropertyOrGetter(PD, false), IdLoc(l), ReceiverLoc(sl),
629  Receiver(st.getTypePtr()) {
630  assert(t->isSpecificPlaceholderType(BuiltinType::PseudoObject));
631  }
632 
635  SourceLocation IdLoc, Expr *Base)
636  : Expr(ObjCPropertyRefExprClass, T, VK, OK, false,
639  PropertyOrGetter(Getter, true), SetterAndMethodRefFlags(Setter, 0),
640  IdLoc(IdLoc), Receiver(Base) {
641  assert(T->isSpecificPlaceholderType(BuiltinType::PseudoObject));
642  }
643 
646  SourceLocation IdLoc,
647  SourceLocation SuperLoc, QualType SuperTy)
648  : Expr(ObjCPropertyRefExprClass, T, VK, OK, false, false, false, false),
649  PropertyOrGetter(Getter, true), SetterAndMethodRefFlags(Setter, 0),
650  IdLoc(IdLoc), ReceiverLoc(SuperLoc), Receiver(SuperTy.getTypePtr()) {
651  assert(T->isSpecificPlaceholderType(BuiltinType::PseudoObject));
652  }
653 
656  SourceLocation IdLoc,
657  SourceLocation ReceiverLoc, ObjCInterfaceDecl *Receiver)
658  : Expr(ObjCPropertyRefExprClass, T, VK, OK, false, false, false, false),
659  PropertyOrGetter(Getter, true), SetterAndMethodRefFlags(Setter, 0),
660  IdLoc(IdLoc), ReceiverLoc(ReceiverLoc), Receiver(Receiver) {
661  assert(T->isSpecificPlaceholderType(BuiltinType::PseudoObject));
662  }
663 
665  : Expr(ObjCPropertyRefExprClass, Empty) {}
666 
667  bool isImplicitProperty() const { return PropertyOrGetter.getInt(); }
668  bool isExplicitProperty() const { return !PropertyOrGetter.getInt(); }
669 
671  assert(!isImplicitProperty());
672  return cast<ObjCPropertyDecl>(PropertyOrGetter.getPointer());
673  }
674 
676  assert(isImplicitProperty());
677  return cast_or_null<ObjCMethodDecl>(PropertyOrGetter.getPointer());
678  }
679 
681  assert(isImplicitProperty());
682  return SetterAndMethodRefFlags.getPointer();
683  }
684 
686  if (isImplicitProperty())
687  return getImplicitPropertyGetter()->getSelector();
688  return getExplicitProperty()->getGetterName();
689  }
690 
692  if (isImplicitProperty())
693  return getImplicitPropertySetter()->getSelector();
694  return getExplicitProperty()->getSetterName();
695  }
696 
697  /// True if the property reference will result in a message to the
698  /// getter.
699  /// This applies to both implicit and explicit property references.
700  bool isMessagingGetter() const {
701  return SetterAndMethodRefFlags.getInt() & MethodRef_Getter;
702  }
703 
704  /// True if the property reference will result in a message to the
705  /// setter.
706  /// This applies to both implicit and explicit property references.
707  bool isMessagingSetter() const {
708  return SetterAndMethodRefFlags.getInt() & MethodRef_Setter;
709  }
710 
711  void setIsMessagingGetter(bool val = true) {
712  setMethodRefFlag(MethodRef_Getter, val);
713  }
714 
715  void setIsMessagingSetter(bool val = true) {
716  setMethodRefFlag(MethodRef_Setter, val);
717  }
718 
719  const Expr *getBase() const {
720  return cast<Expr>(Receiver.get<Stmt*>());
721  }
723  return cast<Expr>(Receiver.get<Stmt*>());
724  }
725 
726  SourceLocation getLocation() const { return IdLoc; }
727 
728  SourceLocation getReceiverLocation() const { return ReceiverLoc; }
729 
731  return QualType(Receiver.get<const Type*>(), 0);
732  }
733 
735  return Receiver.get<ObjCInterfaceDecl*>();
736  }
737 
738  bool isObjectReceiver() const { return Receiver.is<Stmt*>(); }
739  bool isSuperReceiver() const { return Receiver.is<const Type*>(); }
740  bool isClassReceiver() const { return Receiver.is<ObjCInterfaceDecl*>(); }
741 
742  /// Determine the type of the base, regardless of the kind of receiver.
743  QualType getReceiverType(const ASTContext &ctx) const;
744 
745  SourceLocation getBeginLoc() const LLVM_READONLY {
746  return isObjectReceiver() ? getBase()->getBeginLoc()
747  : getReceiverLocation();
748  }
749 
750  SourceLocation getEndLoc() const LLVM_READONLY { return IdLoc; }
751 
752  // Iterators
754  if (Receiver.is<Stmt*>()) {
755  Stmt **begin = reinterpret_cast<Stmt**>(&Receiver); // hack!
756  return child_range(begin, begin+1);
757  }
759  }
760 
761  static bool classof(const Stmt *T) {
762  return T->getStmtClass() == ObjCPropertyRefExprClass;
763  }
764 
765 private:
766  friend class ASTStmtReader;
767  friend class ASTStmtWriter;
768 
769  void setExplicitProperty(ObjCPropertyDecl *D, unsigned methRefFlags) {
770  PropertyOrGetter.setPointer(D);
771  PropertyOrGetter.setInt(false);
772  SetterAndMethodRefFlags.setPointer(nullptr);
773  SetterAndMethodRefFlags.setInt(methRefFlags);
774  }
775 
776  void setImplicitProperty(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter,
777  unsigned methRefFlags) {
778  PropertyOrGetter.setPointer(Getter);
779  PropertyOrGetter.setInt(true);
780  SetterAndMethodRefFlags.setPointer(Setter);
781  SetterAndMethodRefFlags.setInt(methRefFlags);
782  }
783 
784  void setBase(Expr *Base) { Receiver = Base; }
785  void setSuperReceiver(QualType T) { Receiver = T.getTypePtr(); }
786  void setClassReceiver(ObjCInterfaceDecl *D) { Receiver = D; }
787 
788  void setLocation(SourceLocation L) { IdLoc = L; }
789  void setReceiverLocation(SourceLocation Loc) { ReceiverLoc = Loc; }
790 
791  void setMethodRefFlag(MethodRefFlags flag, bool val) {
792  unsigned f = SetterAndMethodRefFlags.getInt();
793  if (val)
794  f |= flag;
795  else
796  f &= ~flag;
797  SetterAndMethodRefFlags.setInt(f);
798  }
799 };
800 
801 /// ObjCSubscriptRefExpr - used for array and dictionary subscripting.
802 /// array[4] = array[3]; dictionary[key] = dictionary[alt_key];
803 class ObjCSubscriptRefExpr : public Expr {
804  // Location of ']' in an indexing expression.
805  SourceLocation RBracket;
806 
807  // array/dictionary base expression.
808  // for arrays, this is a numeric expression. For dictionaries, this is
809  // an objective-c object pointer expression.
810  enum { BASE, KEY, END_EXPR };
811  Stmt* SubExprs[END_EXPR];
812 
813  ObjCMethodDecl *GetAtIndexMethodDecl;
814 
815  // For immutable objects this is null. When ObjCSubscriptRefExpr is to read
816  // an indexed object this is null too.
817  ObjCMethodDecl *SetAtIndexMethodDecl;
818 
819 public:
822  ObjCMethodDecl *getMethod,
823  ObjCMethodDecl *setMethod, SourceLocation RB)
824  : Expr(ObjCSubscriptRefExprClass, T, VK, OK,
825  base->isTypeDependent() || key->isTypeDependent(),
826  base->isValueDependent() || key->isValueDependent(),
827  (base->isInstantiationDependent() ||
828  key->isInstantiationDependent()),
831  RBracket(RB), GetAtIndexMethodDecl(getMethod),
832  SetAtIndexMethodDecl(setMethod) {
833  SubExprs[BASE] = base; SubExprs[KEY] = key;
834  }
835 
837  : Expr(ObjCSubscriptRefExprClass, Empty) {}
838 
839  SourceLocation getRBracket() const { return RBracket; }
840  void setRBracket(SourceLocation RB) { RBracket = RB; }
841 
842  SourceLocation getBeginLoc() const LLVM_READONLY {
843  return SubExprs[BASE]->getBeginLoc();
844  }
845 
846  SourceLocation getEndLoc() const LLVM_READONLY { return RBracket; }
847 
848  Expr *getBaseExpr() const { return cast<Expr>(SubExprs[BASE]); }
849  void setBaseExpr(Stmt *S) { SubExprs[BASE] = S; }
850 
851  Expr *getKeyExpr() const { return cast<Expr>(SubExprs[KEY]); }
852  void setKeyExpr(Stmt *S) { SubExprs[KEY] = S; }
853 
855  return GetAtIndexMethodDecl;
856  }
857 
859  return SetAtIndexMethodDecl;
860  }
861 
862  bool isArraySubscriptRefExpr() const {
863  return getKeyExpr()->getType()->isIntegralOrEnumerationType();
864  }
865 
867  return child_range(SubExprs, SubExprs+END_EXPR);
868  }
869 
870  static bool classof(const Stmt *T) {
871  return T->getStmtClass() == ObjCSubscriptRefExprClass;
872  }
873 
874 private:
875  friend class ASTStmtReader;
876 };
877 
878 /// An expression that sends a message to the given Objective-C
879 /// object or class.
880 ///
881 /// The following contains two message send expressions:
882 ///
883 /// \code
884 /// [[NSString alloc] initWithString:@"Hello"]
885 /// \endcode
886 ///
887 /// The innermost message send invokes the "alloc" class method on the
888 /// NSString class, while the outermost message send invokes the
889 /// "initWithString" instance method on the object returned from
890 /// NSString's "alloc". In all, an Objective-C message send can take
891 /// on four different (although related) forms:
892 ///
893 /// 1. Send to an object instance.
894 /// 2. Send to a class.
895 /// 3. Send to the superclass instance of the current class.
896 /// 4. Send to the superclass of the current class.
897 ///
898 /// All four kinds of message sends are modeled by the ObjCMessageExpr
899 /// class, and can be distinguished via \c getReceiverKind(). Example:
900 ///
901 /// The "void *" trailing objects are actually ONE void * (the
902 /// receiver pointer), and NumArgs Expr *. But due to the
903 /// implementation of children(), these must be together contiguously.
904 class ObjCMessageExpr final
905  : public Expr,
906  private llvm::TrailingObjects<ObjCMessageExpr, void *, SourceLocation> {
907  /// Stores either the selector that this message is sending
908  /// to (when \c HasMethod is zero) or an \c ObjCMethodDecl pointer
909  /// referring to the method that we type-checked against.
910  uintptr_t SelectorOrMethod = 0;
911 
912  enum { NumArgsBitWidth = 16 };
913 
914  /// The number of arguments in the message send, not
915  /// including the receiver.
916  unsigned NumArgs : NumArgsBitWidth;
917 
918  /// The kind of message send this is, which is one of the
919  /// ReceiverKind values.
920  ///
921  /// We pad this out to a byte to avoid excessive masking and shifting.
922  unsigned Kind : 8;
923 
924  /// Whether we have an actual method prototype in \c
925  /// SelectorOrMethod.
926  ///
927  /// When non-zero, we have a method declaration; otherwise, we just
928  /// have a selector.
929  unsigned HasMethod : 1;
930 
931  /// Whether this message send is a "delegate init call",
932  /// i.e. a call of an init method on self from within an init method.
933  unsigned IsDelegateInitCall : 1;
934 
935  /// Whether this message send was implicitly generated by
936  /// the implementation rather than explicitly written by the user.
937  unsigned IsImplicit : 1;
938 
939  /// Whether the locations of the selector identifiers are in a
940  /// "standard" position, a enum SelectorLocationsKind.
941  unsigned SelLocsKind : 2;
942 
943  /// When the message expression is a send to 'super', this is
944  /// the location of the 'super' keyword.
945  SourceLocation SuperLoc;
946 
947  /// The source locations of the open and close square
948  /// brackets ('[' and ']', respectively).
949  SourceLocation LBracLoc, RBracLoc;
950 
951  ObjCMessageExpr(EmptyShell Empty, unsigned NumArgs)
952  : Expr(ObjCMessageExprClass, Empty), Kind(0), HasMethod(false),
953  IsDelegateInitCall(false), IsImplicit(false), SelLocsKind(0) {
954  setNumArgs(NumArgs);
955  }
956 
958  SourceLocation LBracLoc,
959  SourceLocation SuperLoc,
960  bool IsInstanceSuper,
961  QualType SuperType,
962  Selector Sel,
963  ArrayRef<SourceLocation> SelLocs,
964  SelectorLocationsKind SelLocsK,
965  ObjCMethodDecl *Method,
966  ArrayRef<Expr *> Args,
967  SourceLocation RBracLoc,
968  bool isImplicit);
970  SourceLocation LBracLoc,
971  TypeSourceInfo *Receiver,
972  Selector Sel,
973  ArrayRef<SourceLocation> SelLocs,
974  SelectorLocationsKind SelLocsK,
975  ObjCMethodDecl *Method,
976  ArrayRef<Expr *> Args,
977  SourceLocation RBracLoc,
978  bool isImplicit);
980  SourceLocation LBracLoc,
981  Expr *Receiver,
982  Selector Sel,
983  ArrayRef<SourceLocation> SelLocs,
984  SelectorLocationsKind SelLocsK,
985  ObjCMethodDecl *Method,
986  ArrayRef<Expr *> Args,
987  SourceLocation RBracLoc,
988  bool isImplicit);
989 
990  size_t numTrailingObjects(OverloadToken<void *>) const { return NumArgs + 1; }
991 
992  void setNumArgs(unsigned Num) {
993  assert((Num >> NumArgsBitWidth) == 0 && "Num of args is out of range!");
994  NumArgs = Num;
995  }
996 
997  void initArgsAndSelLocs(ArrayRef<Expr *> Args,
998  ArrayRef<SourceLocation> SelLocs,
999  SelectorLocationsKind SelLocsK);
1000 
1001  /// Retrieve the pointer value of the message receiver.
1002  void *getReceiverPointer() const { return *getTrailingObjects<void *>(); }
1003 
1004  /// Set the pointer value of the message receiver.
1005  void setReceiverPointer(void *Value) {
1006  *getTrailingObjects<void *>() = Value;
1007  }
1008 
1009  SelectorLocationsKind getSelLocsKind() const {
1010  return (SelectorLocationsKind)SelLocsKind;
1011  }
1012 
1013  bool hasStandardSelLocs() const {
1014  return getSelLocsKind() != SelLoc_NonStandard;
1015  }
1016 
1017  /// Get a pointer to the stored selector identifiers locations array.
1018  /// No locations will be stored if HasStandardSelLocs is true.
1019  SourceLocation *getStoredSelLocs() {
1020  return getTrailingObjects<SourceLocation>();
1021  }
1022  const SourceLocation *getStoredSelLocs() const {
1023  return getTrailingObjects<SourceLocation>();
1024  }
1025 
1026  /// Get the number of stored selector identifiers locations.
1027  /// No locations will be stored if HasStandardSelLocs is true.
1028  unsigned getNumStoredSelLocs() const {
1029  if (hasStandardSelLocs())
1030  return 0;
1031  return getNumSelectorLocs();
1032  }
1033 
1034  static ObjCMessageExpr *alloc(const ASTContext &C,
1035  ArrayRef<Expr *> Args,
1036  SourceLocation RBraceLoc,
1037  ArrayRef<SourceLocation> SelLocs,
1038  Selector Sel,
1039  SelectorLocationsKind &SelLocsK);
1040  static ObjCMessageExpr *alloc(const ASTContext &C,
1041  unsigned NumArgs,
1042  unsigned NumStoredSelLocs);
1043 
1044 public:
1045  friend class ASTStmtReader;
1046  friend class ASTStmtWriter;
1048 
1049  /// The kind of receiver this message is sending to.
1051  /// The receiver is a class.
1052  Class = 0,
1053 
1054  /// The receiver is an object instance.
1056 
1057  /// The receiver is a superclass.
1059 
1060  /// The receiver is the instance of the superclass object.
1061  SuperInstance
1062  };
1063 
1064  /// Create a message send to super.
1065  ///
1066  /// \param Context The ASTContext in which this expression will be created.
1067  ///
1068  /// \param T The result type of this message.
1069  ///
1070  /// \param VK The value kind of this message. A message returning
1071  /// a l-value or r-value reference will be an l-value or x-value,
1072  /// respectively.
1073  ///
1074  /// \param LBracLoc The location of the open square bracket '['.
1075  ///
1076  /// \param SuperLoc The location of the "super" keyword.
1077  ///
1078  /// \param IsInstanceSuper Whether this is an instance "super"
1079  /// message (otherwise, it's a class "super" message).
1080  ///
1081  /// \param Sel The selector used to determine which method gets called.
1082  ///
1083  /// \param Method The Objective-C method against which this message
1084  /// send was type-checked. May be nullptr.
1085  ///
1086  /// \param Args The message send arguments.
1087  ///
1088  /// \param RBracLoc The location of the closing square bracket ']'.
1089  static ObjCMessageExpr *Create(const ASTContext &Context, QualType T,
1090  ExprValueKind VK,
1091  SourceLocation LBracLoc,
1092  SourceLocation SuperLoc,
1093  bool IsInstanceSuper,
1094  QualType SuperType,
1095  Selector Sel,
1096  ArrayRef<SourceLocation> SelLocs,
1097  ObjCMethodDecl *Method,
1098  ArrayRef<Expr *> Args,
1099  SourceLocation RBracLoc,
1100  bool isImplicit);
1101 
1102  /// Create a class message send.
1103  ///
1104  /// \param Context The ASTContext in which this expression will be created.
1105  ///
1106  /// \param T The result type of this message.
1107  ///
1108  /// \param VK The value kind of this message. A message returning
1109  /// a l-value or r-value reference will be an l-value or x-value,
1110  /// respectively.
1111  ///
1112  /// \param LBracLoc The location of the open square bracket '['.
1113  ///
1114  /// \param Receiver The type of the receiver, including
1115  /// source-location information.
1116  ///
1117  /// \param Sel The selector used to determine which method gets called.
1118  ///
1119  /// \param Method The Objective-C method against which this message
1120  /// send was type-checked. May be nullptr.
1121  ///
1122  /// \param Args The message send arguments.
1123  ///
1124  /// \param RBracLoc The location of the closing square bracket ']'.
1125  static ObjCMessageExpr *Create(const ASTContext &Context, QualType T,
1126  ExprValueKind VK,
1127  SourceLocation LBracLoc,
1128  TypeSourceInfo *Receiver,
1129  Selector Sel,
1130  ArrayRef<SourceLocation> SelLocs,
1131  ObjCMethodDecl *Method,
1132  ArrayRef<Expr *> Args,
1133  SourceLocation RBracLoc,
1134  bool isImplicit);
1135 
1136  /// Create an instance message send.
1137  ///
1138  /// \param Context The ASTContext in which this expression will be created.
1139  ///
1140  /// \param T The result type of this message.
1141  ///
1142  /// \param VK The value kind of this message. A message returning
1143  /// a l-value or r-value reference will be an l-value or x-value,
1144  /// respectively.
1145  ///
1146  /// \param LBracLoc The location of the open square bracket '['.
1147  ///
1148  /// \param Receiver The expression used to produce the object that
1149  /// will receive this message.
1150  ///
1151  /// \param Sel The selector used to determine which method gets called.
1152  ///
1153  /// \param Method The Objective-C method against which this message
1154  /// send was type-checked. May be nullptr.
1155  ///
1156  /// \param Args The message send arguments.
1157  ///
1158  /// \param RBracLoc The location of the closing square bracket ']'.
1159  static ObjCMessageExpr *Create(const ASTContext &Context, QualType T,
1160  ExprValueKind VK,
1161  SourceLocation LBracLoc,
1162  Expr *Receiver,
1163  Selector Sel,
1164  ArrayRef<SourceLocation> SeLocs,
1165  ObjCMethodDecl *Method,
1166  ArrayRef<Expr *> Args,
1167  SourceLocation RBracLoc,
1168  bool isImplicit);
1169 
1170  /// Create an empty Objective-C message expression, to be
1171  /// filled in by subsequent calls.
1172  ///
1173  /// \param Context The context in which the message send will be created.
1174  ///
1175  /// \param NumArgs The number of message arguments, not including
1176  /// the receiver.
1177  static ObjCMessageExpr *CreateEmpty(const ASTContext &Context,
1178  unsigned NumArgs,
1179  unsigned NumStoredSelLocs);
1180 
1181  /// Indicates whether the message send was implicitly
1182  /// generated by the implementation. If false, it was written explicitly
1183  /// in the source code.
1184  bool isImplicit() const { return IsImplicit; }
1185 
1186  /// Determine the kind of receiver that this message is being
1187  /// sent to.
1189 
1190  /// Source range of the receiver.
1191  SourceRange getReceiverRange() const;
1192 
1193  /// Determine whether this is an instance message to either a
1194  /// computed object or to super.
1195  bool isInstanceMessage() const {
1196  return getReceiverKind() == Instance || getReceiverKind() == SuperInstance;
1197  }
1198 
1199  /// Determine whether this is an class message to either a
1200  /// specified class or to super.
1201  bool isClassMessage() const {
1202  return getReceiverKind() == Class || getReceiverKind() == SuperClass;
1203  }
1204 
1205  /// Returns the object expression (receiver) for an instance message,
1206  /// or null for a message that is not an instance message.
1208  if (getReceiverKind() == Instance)
1209  return static_cast<Expr *>(getReceiverPointer());
1210 
1211  return nullptr;
1212  }
1213  const Expr *getInstanceReceiver() const {
1214  return const_cast<ObjCMessageExpr*>(this)->getInstanceReceiver();
1215  }
1216 
1217  /// Turn this message send into an instance message that
1218  /// computes the receiver object with the given expression.
1220  Kind = Instance;
1221  setReceiverPointer(rec);
1222  }
1223 
1224  /// Returns the type of a class message send, or NULL if the
1225  /// message is not a class message.
1227  if (TypeSourceInfo *TSInfo = getClassReceiverTypeInfo())
1228  return TSInfo->getType();
1229 
1230  return {};
1231  }
1232 
1233  /// Returns a type-source information of a class message
1234  /// send, or nullptr if the message is not a class message.
1236  if (getReceiverKind() == Class)
1237  return reinterpret_cast<TypeSourceInfo *>(getReceiverPointer());
1238  return nullptr;
1239  }
1240 
1242  Kind = Class;
1243  setReceiverPointer(TSInfo);
1244  }
1245 
1246  /// Retrieve the location of the 'super' keyword for a class
1247  /// or instance message to 'super', otherwise an invalid source location.
1249  if (getReceiverKind() == SuperInstance || getReceiverKind() == SuperClass)
1250  return SuperLoc;
1251 
1252  return SourceLocation();
1253  }
1254 
1255  /// Retrieve the receiver type to which this message is being directed.
1256  ///
1257  /// This routine cross-cuts all of the different kinds of message
1258  /// sends to determine what the underlying (statically known) type
1259  /// of the receiver will be; use \c getReceiverKind() to determine
1260  /// whether the message is a class or an instance method, whether it
1261  /// is a send to super or not, etc.
1262  ///
1263  /// \returns The type of the receiver.
1264  QualType getReceiverType() const;
1265 
1266  /// Retrieve the Objective-C interface to which this message
1267  /// is being directed, if known.
1268  ///
1269  /// This routine cross-cuts all of the different kinds of message
1270  /// sends to determine what the underlying (statically known) type
1271  /// of the receiver will be; use \c getReceiverKind() to determine
1272  /// whether the message is a class or an instance method, whether it
1273  /// is a send to super or not, etc.
1274  ///
1275  /// \returns The Objective-C interface if known, otherwise nullptr.
1276  ObjCInterfaceDecl *getReceiverInterface() const;
1277 
1278  /// Retrieve the type referred to by 'super'.
1279  ///
1280  /// The returned type will either be an ObjCInterfaceType (for an
1281  /// class message to super) or an ObjCObjectPointerType that refers
1282  /// to a class (for an instance message to super);
1284  if (getReceiverKind() == SuperInstance || getReceiverKind() == SuperClass)
1285  return QualType::getFromOpaquePtr(getReceiverPointer());
1286 
1287  return QualType();
1288  }
1289 
1290  void setSuper(SourceLocation Loc, QualType T, bool IsInstanceSuper) {
1291  Kind = IsInstanceSuper? SuperInstance : SuperClass;
1292  SuperLoc = Loc;
1293  setReceiverPointer(T.getAsOpaquePtr());
1294  }
1295 
1296  Selector getSelector() const;
1297 
1299  HasMethod = false;
1300  SelectorOrMethod = reinterpret_cast<uintptr_t>(S.getAsOpaquePtr());
1301  }
1302 
1304  if (HasMethod)
1305  return reinterpret_cast<const ObjCMethodDecl *>(SelectorOrMethod);
1306 
1307  return nullptr;
1308  }
1309 
1311  if (HasMethod)
1312  return reinterpret_cast<ObjCMethodDecl *>(SelectorOrMethod);
1313 
1314  return nullptr;
1315  }
1316 
1318  HasMethod = true;
1319  SelectorOrMethod = reinterpret_cast<uintptr_t>(MD);
1320  }
1321 
1323  if (HasMethod) return getMethodDecl()->getMethodFamily();
1324  return getSelector().getMethodFamily();
1325  }
1326 
1327  /// Return the number of actual arguments in this message,
1328  /// not counting the receiver.
1329  unsigned getNumArgs() const { return NumArgs; }
1330 
1331  /// Retrieve the arguments to this message, not including the
1332  /// receiver.
1334  return reinterpret_cast<Expr **>(getTrailingObjects<void *>() + 1);
1335  }
1336  const Expr * const *getArgs() const {
1337  return reinterpret_cast<const Expr *const *>(getTrailingObjects<void *>() +
1338  1);
1339  }
1340 
1341  /// getArg - Return the specified argument.
1342  Expr *getArg(unsigned Arg) {
1343  assert(Arg < NumArgs && "Arg access out of range!");
1344  return getArgs()[Arg];
1345  }
1346  const Expr *getArg(unsigned Arg) const {
1347  assert(Arg < NumArgs && "Arg access out of range!");
1348  return getArgs()[Arg];
1349  }
1350 
1351  /// setArg - Set the specified argument.
1352  void setArg(unsigned Arg, Expr *ArgExpr) {
1353  assert(Arg < NumArgs && "Arg access out of range!");
1354  getArgs()[Arg] = ArgExpr;
1355  }
1356 
1357  /// isDelegateInitCall - Answers whether this message send has been
1358  /// tagged as a "delegate init call", i.e. a call to a method in the
1359  /// -init family on self from within an -init method implementation.
1360  bool isDelegateInitCall() const { return IsDelegateInitCall; }
1361  void setDelegateInitCall(bool isDelegate) { IsDelegateInitCall = isDelegate; }
1362 
1363  SourceLocation getLeftLoc() const { return LBracLoc; }
1364  SourceLocation getRightLoc() const { return RBracLoc; }
1365 
1367  if (isImplicit())
1368  return getBeginLoc();
1369  return getSelectorLoc(0);
1370  }
1371 
1372  SourceLocation getSelectorLoc(unsigned Index) const {
1373  assert(Index < getNumSelectorLocs() && "Index out of range!");
1374  if (hasStandardSelLocs())
1375  return getStandardSelectorLoc(Index, getSelector(),
1376  getSelLocsKind() == SelLoc_StandardWithSpace,
1377  llvm::makeArrayRef(const_cast<Expr**>(getArgs()),
1378  getNumArgs()),
1379  RBracLoc);
1380  return getStoredSelLocs()[Index];
1381  }
1382 
1383  void getSelectorLocs(SmallVectorImpl<SourceLocation> &SelLocs) const;
1384 
1385  unsigned getNumSelectorLocs() const {
1386  if (isImplicit())
1387  return 0;
1388  Selector Sel = getSelector();
1389  if (Sel.isUnarySelector())
1390  return 1;
1391  return Sel.getNumArgs();
1392  }
1393 
1395  LBracLoc = R.getBegin();
1396  RBracLoc = R.getEnd();
1397  }
1398 
1399  SourceLocation getBeginLoc() const LLVM_READONLY { return LBracLoc; }
1400  SourceLocation getEndLoc() const LLVM_READONLY { return RBracLoc; }
1401 
1402  // Iterators
1404 
1407 
1408  llvm::iterator_range<arg_iterator> arguments() {
1409  return llvm::make_range(arg_begin(), arg_end());
1410  }
1411 
1412  llvm::iterator_range<const_arg_iterator> arguments() const {
1413  return llvm::make_range(arg_begin(), arg_end());
1414  }
1415 
1416  arg_iterator arg_begin() { return reinterpret_cast<Stmt **>(getArgs()); }
1417 
1419  return reinterpret_cast<Stmt **>(getArgs() + NumArgs);
1420  }
1421 
1423  return reinterpret_cast<Stmt const * const*>(getArgs());
1424  }
1425 
1427  return reinterpret_cast<Stmt const * const*>(getArgs() + NumArgs);
1428  }
1429 
1430  static bool classof(const Stmt *T) {
1431  return T->getStmtClass() == ObjCMessageExprClass;
1432  }
1433 };
1434 
1435 /// ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
1436 /// (similar in spirit to MemberExpr).
1437 class ObjCIsaExpr : public Expr {
1438  /// Base - the expression for the base object pointer.
1439  Stmt *Base;
1440 
1441  /// IsaMemberLoc - This is the location of the 'isa'.
1442  SourceLocation IsaMemberLoc;
1443 
1444  /// OpLoc - This is the location of '.' or '->'
1445  SourceLocation OpLoc;
1446 
1447  /// IsArrow - True if this is "X->F", false if this is "X.F".
1448  bool IsArrow;
1449 
1450 public:
1451  ObjCIsaExpr(Expr *base, bool isarrow, SourceLocation l, SourceLocation oploc,
1452  QualType ty)
1453  : Expr(ObjCIsaExprClass, ty, VK_LValue, OK_Ordinary,
1454  /*TypeDependent=*/false, base->isValueDependent(),
1455  base->isInstantiationDependent(),
1456  /*ContainsUnexpandedParameterPack=*/false),
1457  Base(base), IsaMemberLoc(l), OpLoc(oploc), IsArrow(isarrow) {}
1458 
1459  /// Build an empty expression.
1460  explicit ObjCIsaExpr(EmptyShell Empty) : Expr(ObjCIsaExprClass, Empty) {}
1461 
1462  void setBase(Expr *E) { Base = E; }
1463  Expr *getBase() const { return cast<Expr>(Base); }
1464 
1465  bool isArrow() const { return IsArrow; }
1466  void setArrow(bool A) { IsArrow = A; }
1467 
1468  /// getMemberLoc - Return the location of the "member", in X->F, it is the
1469  /// location of 'F'.
1470  SourceLocation getIsaMemberLoc() const { return IsaMemberLoc; }
1471  void setIsaMemberLoc(SourceLocation L) { IsaMemberLoc = L; }
1472 
1473  SourceLocation getOpLoc() const { return OpLoc; }
1474  void setOpLoc(SourceLocation L) { OpLoc = L; }
1475 
1476  SourceLocation getBeginLoc() const LLVM_READONLY {
1477  return getBase()->getBeginLoc();
1478  }
1479 
1480  SourceLocation getBaseLocEnd() const LLVM_READONLY {
1481  return getBase()->getEndLoc();
1482  }
1483 
1484  SourceLocation getEndLoc() const LLVM_READONLY { return IsaMemberLoc; }
1485 
1486  SourceLocation getExprLoc() const LLVM_READONLY { return IsaMemberLoc; }
1487 
1488  // Iterators
1489  child_range children() { return child_range(&Base, &Base+1); }
1490 
1491  static bool classof(const Stmt *T) {
1492  return T->getStmtClass() == ObjCIsaExprClass;
1493  }
1494 };
1495 
1496 /// ObjCIndirectCopyRestoreExpr - Represents the passing of a function
1497 /// argument by indirect copy-restore in ARC. This is used to support
1498 /// passing indirect arguments with the wrong lifetime, e.g. when
1499 /// passing the address of a __strong local variable to an 'out'
1500 /// parameter. This expression kind is only valid in an "argument"
1501 /// position to some sort of call expression.
1502 ///
1503 /// The parameter must have type 'pointer to T', and the argument must
1504 /// have type 'pointer to U', where T and U agree except possibly in
1505 /// qualification. If the argument value is null, then a null pointer
1506 /// is passed; otherwise it points to an object A, and:
1507 /// 1. A temporary object B of type T is initialized, either by
1508 /// zero-initialization (used when initializing an 'out' parameter)
1509 /// or copy-initialization (used when initializing an 'inout'
1510 /// parameter).
1511 /// 2. The address of the temporary is passed to the function.
1512 /// 3. If the call completes normally, A is move-assigned from B.
1513 /// 4. Finally, A is destroyed immediately.
1514 ///
1515 /// Currently 'T' must be a retainable object lifetime and must be
1516 /// __autoreleasing; this qualifier is ignored when initializing
1517 /// the value.
1519  friend class ASTReader;
1520  friend class ASTStmtReader;
1521 
1522  Stmt *Operand;
1523 
1524  // unsigned ObjCIndirectCopyRestoreBits.ShouldCopy : 1;
1525 
1526  explicit ObjCIndirectCopyRestoreExpr(EmptyShell Empty)
1527  : Expr(ObjCIndirectCopyRestoreExprClass, Empty) {}
1528 
1529  void setShouldCopy(bool shouldCopy) {
1530  ObjCIndirectCopyRestoreExprBits.ShouldCopy = shouldCopy;
1531  }
1532 
1533 public:
1534  ObjCIndirectCopyRestoreExpr(Expr *operand, QualType type, bool shouldCopy)
1535  : Expr(ObjCIndirectCopyRestoreExprClass, type, VK_LValue, OK_Ordinary,
1536  operand->isTypeDependent(), operand->isValueDependent(),
1537  operand->isInstantiationDependent(),
1538  operand->containsUnexpandedParameterPack()),
1539  Operand(operand) {
1540  setShouldCopy(shouldCopy);
1541  }
1542 
1543  Expr *getSubExpr() { return cast<Expr>(Operand); }
1544  const Expr *getSubExpr() const { return cast<Expr>(Operand); }
1545 
1546  /// shouldCopy - True if we should do the 'copy' part of the
1547  /// copy-restore. If false, the temporary will be zero-initialized.
1548  bool shouldCopy() const { return ObjCIndirectCopyRestoreExprBits.ShouldCopy; }
1549 
1550  child_range children() { return child_range(&Operand, &Operand+1); }
1551 
1552  // Source locations are determined by the subexpression.
1553  SourceLocation getBeginLoc() const LLVM_READONLY {
1554  return Operand->getBeginLoc();
1555  }
1556  SourceLocation getEndLoc() const LLVM_READONLY {
1557  return Operand->getEndLoc();
1558  }
1559 
1560  SourceLocation getExprLoc() const LLVM_READONLY {
1561  return getSubExpr()->getExprLoc();
1562  }
1563 
1564  static bool classof(const Stmt *s) {
1565  return s->getStmtClass() == ObjCIndirectCopyRestoreExprClass;
1566  }
1567 };
1568 
1569 /// An Objective-C "bridged" cast expression, which casts between
1570 /// Objective-C pointers and C pointers, transferring ownership in the process.
1571 ///
1572 /// \code
1573 /// NSString *str = (__bridge_transfer NSString *)CFCreateString();
1574 /// \endcode
1576  : public ExplicitCastExpr,
1577  private llvm::TrailingObjects<
1578  ObjCBridgedCastExpr, CastExpr::BasePathSizeTy, CXXBaseSpecifier *> {
1579  friend class ASTStmtReader;
1580  friend class ASTStmtWriter;
1581  friend class CastExpr;
1582  friend TrailingObjects;
1583 
1584  SourceLocation LParenLoc;
1585  SourceLocation BridgeKeywordLoc;
1586  unsigned Kind : 2;
1587 
1588  size_t numTrailingObjects(OverloadToken<CastExpr::BasePathSizeTy>) const {
1589  return path_empty() ? 0 : 1;
1590  }
1591 
1592 public:
1594  CastKind CK, SourceLocation BridgeKeywordLoc,
1595  TypeSourceInfo *TSInfo, Expr *Operand)
1596  : ExplicitCastExpr(ObjCBridgedCastExprClass, TSInfo->getType(), VK_RValue,
1597  CK, Operand, 0, TSInfo),
1598  LParenLoc(LParenLoc), BridgeKeywordLoc(BridgeKeywordLoc), Kind(Kind) {}
1599 
1600  /// Construct an empty Objective-C bridged cast.
1602  : ExplicitCastExpr(ObjCBridgedCastExprClass, Shell, 0) {}
1603 
1604  SourceLocation getLParenLoc() const { return LParenLoc; }
1605 
1606  /// Determine which kind of bridge is being performed via this cast.
1608  return static_cast<ObjCBridgeCastKind>(Kind);
1609  }
1610 
1611  /// Retrieve the kind of bridge being performed as a string.
1612  StringRef getBridgeKindName() const;
1613 
1614  /// The location of the bridge keyword.
1615  SourceLocation getBridgeKeywordLoc() const { return BridgeKeywordLoc; }
1616 
1617  SourceLocation getBeginLoc() const LLVM_READONLY { return LParenLoc; }
1618 
1619  SourceLocation getEndLoc() const LLVM_READONLY {
1620  return getSubExpr()->getEndLoc();
1621  }
1622 
1623  static bool classof(const Stmt *T) {
1624  return T->getStmtClass() == ObjCBridgedCastExprClass;
1625  }
1626 };
1627 
1628 /// A runtime availability query.
1629 ///
1630 /// There are 2 ways to spell this node:
1631 /// \code
1632 /// @available(macos 10.10, ios 8, *); // Objective-C
1633 /// __builtin_available(macos 10.10, ios 8, *); // C, C++, and Objective-C
1634 /// \endcode
1635 ///
1636 /// Note that we only need to keep track of one \c VersionTuple here, which is
1637 /// the one that corresponds to the current deployment target. This is meant to
1638 /// be used in the condition of an \c if, but it is also usable as top level
1639 /// expressions.
1640 ///
1642  friend class ASTStmtReader;
1643 
1644  VersionTuple VersionToCheck;
1645  SourceLocation AtLoc, RParen;
1646 
1647 public:
1648  ObjCAvailabilityCheckExpr(VersionTuple VersionToCheck, SourceLocation AtLoc,
1649  SourceLocation RParen, QualType Ty)
1650  : Expr(ObjCAvailabilityCheckExprClass, Ty, VK_RValue, OK_Ordinary, false,
1651  false, false, false),
1652  VersionToCheck(VersionToCheck), AtLoc(AtLoc), RParen(RParen) {}
1653 
1655  : Expr(ObjCAvailabilityCheckExprClass, Shell) {}
1656 
1657  SourceLocation getBeginLoc() const { return AtLoc; }
1658  SourceLocation getEndLoc() const { return RParen; }
1659  SourceRange getSourceRange() const { return {AtLoc, RParen}; }
1660 
1661  /// This may be '*', in which case this should fold to true.
1662  bool hasVersion() const { return !VersionToCheck.empty(); }
1663  VersionTuple getVersion() { return VersionToCheck; }
1664 
1667  }
1668 
1669  static bool classof(const Stmt *T) {
1670  return T->getStmtClass() == ObjCAvailabilityCheckExprClass;
1671  }
1672 };
1673 
1674 } // namespace clang
1675 
1676 #endif // LLVM_CLANG_AST_EXPROBJC_H
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
Definition: ExprObjC.h:577
ObjCIndirectCopyRestoreExpr - Represents the passing of a function argument by indirect copy-restore ...
Definition: ExprObjC.h:1518
For nullary selectors, immediately before the end: "[foo release]" / "-(void)release;" Or with a spac...
bool getValue() const
Definition: ExprObjC.h:94
The receiver is an object instance.
Definition: ExprObjC.h:1055
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprObjC.h:842
SourceLocation getOpLoc() const
Definition: ExprObjC.h:1473
ObjCDictionaryElement getKeyValueElement(unsigned Index) const
Definition: ExprObjC.h:344
child_range children()
Definition: ExprObjC.h:104
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprObjC.h:1553
Smart pointer class that efficiently represents Objective-C method names.
A (possibly-)qualified type.
Definition: Type.h:642
static bool classof(const Stmt *T)
Definition: ExprObjC.h:378
void * getAsOpaquePtr() const
child_range children()
Definition: ExprObjC.h:753
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprObjC.h:97
ObjCMethodDecl * getAtIndexMethodDecl() const
Definition: ExprObjC.h:854
Expr(StmtClass SC, QualType T, ExprValueKind VK, ExprObjectKind OK, bool TD, bool VD, bool ID, bool ContainsUnexpandedParameterPack)
Definition: Expr.h:109
SourceLocation EllipsisLoc
The location of the ellipsis, if this element is a pack expansion.
Definition: ExprObjC.h:279
bool isSuperReceiver() const
Definition: ExprObjC.h:739
SourceLocation getEndLoc() const LLVM_READONLY
Definition: ExprObjC.h:500
ObjCBridgeCastKind
The kind of bridging performed by the Objective-C bridge cast.
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:30
ObjCProtocolDecl * getProtocol() const
Definition: ExprObjC.h:490
Stmt - This represents one statement.
Definition: Stmt.h:66
ObjCMethodDecl * setAtIndexMethodDecl() const
Definition: ExprObjC.h:858
void setArrow(bool A)
Definition: ExprObjC.h:1466
C Language Family Type Representation.
bool isSpecificPlaceholderType(unsigned K) const
Test for a specific placeholder type.
Definition: Type.h:6484
void setAtLoc(SourceLocation L)
Definition: ExprObjC.h:447
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprObjC.h:499
void setRBracket(SourceLocation RB)
Definition: ExprObjC.h:840
ObjCMethodDecl * getImplicitPropertySetter() const
Definition: ExprObjC.h:680
StringRef P
const_arg_iterator arg_end() const
Definition: ExprObjC.h:160
ObjCStringLiteral(EmptyShell Empty)
Definition: ExprObjC.h:60
SourceLocation getExprLoc() const LLVM_READONLY
Definition: ExprObjC.h:1560
void setSuper(SourceLocation Loc, QualType T, bool IsInstanceSuper)
Definition: ExprObjC.h:1290
The base class of the type hierarchy.
Definition: Type.h:1415
llvm::iterator_range< child_iterator > child_range
Definition: Stmt.h:460
ObjCSubscriptRefExpr - used for array and dictionary subscripting.
Definition: ExprObjC.h:803
void setValue(bool V)
Definition: ExprObjC.h:95
A container of type source information.
Definition: Decl.h:86
void setInstanceReceiver(Expr *rec)
Turn this message send into an instance message that computes the receiver object with the given expr...
Definition: ExprObjC.h:1219
ObjCBoxedExpr(Expr *E, QualType T, ObjCMethodDecl *method, SourceRange R)
Definition: ExprObjC.h:125
void setLocation(SourceLocation L)
Definition: ExprObjC.h:557
void setDelegateInitCall(bool isDelegate)
Definition: ExprObjC.h:1361
void setProtocol(ObjCProtocolDecl *P)
Definition: ExprObjC.h:491
SourceLocation getAtLoc() const
Definition: ExprObjC.h:67
ObjCPropertyRefExpr(ObjCPropertyDecl *PD, QualType t, ExprValueKind VK, ExprObjectKind OK, SourceLocation l, Expr *base)
Definition: ExprObjC.h:611
Selector getSetterSelector() const
Definition: ExprObjC.h:691
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC &#39;id&#39; type.
Definition: ExprObjC.h:1437
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprObjC.h:144
unsigned NumExpansionsPlusOne
If non-zero, the number of elements that this pack expansion will expand to (+1). ...
Definition: ExprObjC.h:283
SourceLocation getAtLoc() const
Definition: ExprObjC.h:445
void setOpLoc(SourceLocation L)
Definition: ExprObjC.h:1474
ObjCInterfaceDecl * getClassReceiver() const
Definition: ExprObjC.h:734
bool isArrow() const
Definition: ExprObjC.h:1465
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
SourceLocation getLeftLoc() const
Definition: ExprObjC.h:1363
ObjCBridgedCastExpr(EmptyShell Shell)
Construct an empty Objective-C bridged cast.
Definition: ExprObjC.h:1601
const StringLiteral * getString() const
Definition: ExprObjC.h:64
static bool classof(const Stmt *T)
Definition: ExprObjC.h:1491
child_range children()
Definition: ExprObjC.h:457
ObjCPropertyRefExpr(EmptyShell Empty)
Definition: ExprObjC.h:664
ReceiverKind
The kind of receiver this message is sending to.
Definition: ExprObjC.h:1050
const_arg_iterator arg_end() const
Definition: ExprObjC.h:1426
SourceRange getSourceRange() const LLVM_READONLY
Definition: ExprObjC.h:147
static bool classof(const Stmt *T)
Definition: ExprObjC.h:570
child_range children()
Definition: ExprObjC.h:568
ObjCPropertyDecl * getExplicitProperty() const
Definition: ExprObjC.h:670
void setAtLoc(SourceLocation L)
Definition: ExprObjC.h:68
SourceLocation getAtLoc() const
Definition: ExprObjC.h:494
TypeSourceInfo * getEncodedTypeSourceInfo() const
Definition: ExprObjC.h:409
SourceLocation getBaseLocEnd() const LLVM_READONLY
Definition: ExprObjC.h:1480
An element in an Objective-C dictionary literal.
Definition: ExprObjC.h:239
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
Internal struct for storing Key/value pair.
Definition: ExprObjC.h:268
ObjCMethodFamily
A family of Objective-C methods.
void setKeyExpr(Stmt *S)
Definition: ExprObjC.h:852
bool isExplicitProperty() const
Definition: ExprObjC.h:668
ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter, QualType T, ExprValueKind VK, ExprObjectKind OK, SourceLocation IdLoc, Expr *Base)
Definition: ExprObjC.h:633
child_range children()
Definition: ExprObjC.h:227
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:280
StringLiteral * getString()
Definition: ExprObjC.h:63
ObjCEncodeExpr(EmptyShell Empty)
Definition: ExprObjC.h:400
ObjCIndirectCopyRestoreExprBitfields ObjCIndirectCopyRestoreExprBits
Definition: Stmt.h:310
ObjCSubscriptRefExpr(Expr *base, Expr *key, QualType T, ExprValueKind VK, ExprObjectKind OK, ObjCMethodDecl *getMethod, ObjCMethodDecl *setMethod, SourceLocation RB)
Definition: ExprObjC.h:820
bool isClassMessage() const
Determine whether this is an class message to either a specified class or to super.
Definition: ExprObjC.h:1201
ObjCBoxedExpr(EmptyShell Empty)
Definition: ExprObjC.h:132
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp, [NSNumber numberWithInt:42]];.
Definition: ExprObjC.h:171
ObjCSelectorExpr(QualType T, Selector selInfo, SourceLocation at, SourceLocation rp)
Definition: ExprObjC.h:434
SourceLocation getEndLoc() const LLVM_READONLY
Definition: ExprObjC.h:198
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:110
Selector getSelector() const
Definition: ExprObjC.h:442
bool isUnarySelector() const
SourceLocation getOpLoc() const
Definition: ExprObjC.h:564
bool isArrow() const
Definition: ExprObjC.h:551
const Expr * getElement(unsigned Index) const
Definition: ExprObjC.h:217
Expr * getKeyExpr() const
Definition: ExprObjC.h:851
ObjCBoolLiteralExpr(bool val, QualType Ty, SourceLocation l)
Definition: ExprObjC.h:87
SelectorLocationsKind
Whether all locations of the selector identifiers are in a "standard" position.
bool isMessagingSetter() const
True if the property reference will result in a message to the setter.
Definition: ExprObjC.h:707
Expr * getBaseExpr() const
Definition: ExprObjC.h:848
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
void setSelector(Selector S)
Definition: ExprObjC.h:443
void setLocation(SourceLocation L)
Definition: ExprObjC.h:101
SourceLocation getIsaMemberLoc() const
getMemberLoc - Return the location of the "member", in X->F, it is the location of &#39;F&#39;...
Definition: ExprObjC.h:1470
unsigned getNumSelectorLocs() const
Definition: ExprObjC.h:1385
bool isClassReceiver() const
Definition: ExprObjC.h:740
SourceLocation getEndLoc() const LLVM_READONLY
Definition: ExprObjC.h:145
const Expr *const * getElements() const
Retrieve elements of array of literals.
Definition: ExprObjC.h:205
void setString(StringLiteral *S)
Definition: ExprObjC.h:65
ObjCStringLiteral, used for Objective-C string literals i.e.
Definition: ExprObjC.h:51
static bool classof(const Stmt *T)
Definition: ExprObjC.h:1430
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6046
ObjCIsaExpr(Expr *base, bool isarrow, SourceLocation l, SourceLocation oploc, QualType ty)
Definition: ExprObjC.h:1451
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:2795
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2056
Expr * Key
The key for the dictionary element.
Definition: ExprObjC.h:241
ObjCMethodDecl * getArrayWithObjectsMethod() const
Definition: ExprObjC.h:222
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:166
void * getAsOpaquePtr() const
Definition: Type.h:687
An ordinary object is located at an address in memory.
Definition: Specifiers.h:126
Represents an ObjC class declaration.
Definition: DeclObjC.h:1164
child_range children()
Definition: ExprObjC.h:866
SourceLocation getLocation() const
Definition: ExprObjC.h:100
Iterator for iterating over Stmt * arrays that contain only Expr *.
Definition: Stmt.h:345
const Expr *const * getArgs() const
Definition: ExprObjC.h:1336
ObjCMethodDecl * getDictWithObjectsMethod() const
Definition: ExprObjC.h:358
ObjCBoolLiteralExpr(EmptyShell Empty)
Definition: ExprObjC.h:91
ObjCIvarDecl * getDecl()
Definition: ExprObjC.h:543
SourceLocation getEndLoc() const LLVM_READONLY
Definition: ExprObjC.h:750
Const iterator for iterating over Stmt * arrays that contain only Expr *.
Definition: Stmt.h:359
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprObjC.h:1476
static bool classof(const Stmt *T)
Definition: ExprObjC.h:761
SourceLocation getRBracket() const
Definition: ExprObjC.h:839
SourceLocation getEndLoc() const LLVM_READONLY
Definition: ExprObjC.h:1619
CastKind
CastKind - The kind of operation required for a conversion.
SourceRange getSourceRange() const LLVM_READONLY
Definition: ExprObjC.h:199
SourceLocation getRParenLoc() const
Definition: ExprObjC.h:446
SourceLocation getEndLoc() const LLVM_READONLY
Definition: ExprObjC.h:71
void setIsMessagingGetter(bool val=true)
Definition: ExprObjC.h:711
ObjCAvailabilityCheckExpr(VersionTuple VersionToCheck, SourceLocation AtLoc, SourceLocation RParen, QualType Ty)
Definition: ExprObjC.h:1648
ObjCEncodeExpr(QualType T, TypeSourceInfo *EncodedType, SourceLocation at, SourceLocation rp)
Definition: ExprObjC.h:391
ObjCMethodDecl * getBoxingMethod() const
Definition: ExprObjC.h:138
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprObjC.h:1617
This represents one expression.
Definition: Expr.h:105
const Expr * getInstanceReceiver() const
Definition: ExprObjC.h:1213
ObjCIvarRefExpr(EmptyShell Empty)
Definition: ExprObjC.h:540
ObjCIsaExpr(EmptyShell Empty)
Build an empty expression.
Definition: ExprObjC.h:1460
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:107
SourceLocation getExprLoc() const LLVM_READONLY
Definition: ExprObjC.h:1486
SourceLocation getEndLoc() const
Definition: ExprObjC.h:1658
SourceLocation getStandardSelectorLoc(unsigned Index, Selector Sel, bool WithArgSpace, ArrayRef< Expr *> Args, SourceLocation EndLoc)
Get the "standard" location of a selector identifier, e.g: For nullary selectors, immediately before ...
SourceLocation getEndLoc() const LLVM_READONLY
Definition: ExprObjC.h:1400
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprObjC.h:415
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
Definition: ExprObjC.h:288
ObjCSelectorExpr used for @selector in Objective-C.
Definition: ExprObjC.h:429
Expr ** getArgs()
Retrieve the arguments to this message, not including the receiver.
Definition: ExprObjC.h:1333
ObjCPropertyRefExpr(ObjCPropertyDecl *PD, QualType t, ExprValueKind VK, ExprObjectKind OK, SourceLocation l, SourceLocation sl, QualType st)
Definition: ExprObjC.h:622
static bool classof(const Stmt *T)
Definition: ExprObjC.h:870
ObjCStringLiteral(StringLiteral *SL, QualType T, SourceLocation L)
Definition: ExprObjC.h:56
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
QualType getType() const
Definition: Expr.h:127
Expr * getElement(unsigned Index)
getElement - Return the Element at the specified index.
Definition: ExprObjC.h:213
static OMPLinearClause * CreateEmpty(const ASTContext &C, unsigned NumVars)
Creates an empty clause with the place for NumVars variables.
Optional< unsigned > NumExpansions
The number of elements this pack expansion will expand to, if this is a pack expansion and is known...
Definition: ExprObjC.h:251
void setRParenLoc(SourceLocation L)
Definition: ExprObjC.h:497
QualType getEncodedType() const
Definition: ExprObjC.h:407
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:904
void setIsArrow(bool A)
Definition: ExprObjC.h:553
ObjCMethodDecl * getImplicitPropertyGetter() const
Definition: ExprObjC.h:675
SourceLocation getEnd() const
static bool classof(const Stmt *T)
Definition: ExprObjC.h:461
void setAtLoc(SourceLocation L)
Definition: ExprObjC.h:403
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
Definition: ExprObjC.h:1188
StmtIterator child_iterator
Child Iterators: All subclasses must implement &#39;children&#39; to permit easy iteration over the substatem...
Definition: Stmt.h:457
unsigned getNumArgs() const
void setBase(Expr *base)
Definition: ExprObjC.h:549
void setRParenLoc(SourceLocation L)
Definition: ExprObjC.h:448
The result type of a method or function.
ObjCBridgeCastKind getBridgeKind() const
Determine which kind of bridge is being performed via this cast.
Definition: ExprObjC.h:1607
const_arg_iterator arg_begin() const
Definition: ExprObjC.h:1422
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
Definition: opencl-c.h:82
ObjCIvarRefExpr(ObjCIvarDecl *d, QualType t, SourceLocation l, SourceLocation oploc, Expr *base, bool arrow=false, bool freeIvar=false)
Definition: ExprObjC.h:528
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: ExprObjC.h:1342
SourceLocation getEndLoc() const LLVM_READONLY
Definition: Stmt.cpp:293
ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter, QualType T, ExprValueKind VK, ExprObjectKind OK, SourceLocation IdLoc, SourceLocation ReceiverLoc, ObjCInterfaceDecl *Receiver)
Definition: ExprObjC.h:654
SourceLocation getProtocolIdLoc() const
Definition: ExprObjC.h:493
ObjCSubscriptRefExpr(EmptyShell Empty)
Definition: ExprObjC.h:836
unsigned getNumArgs() const
Return the number of actual arguments in this message, not counting the receiver. ...
Definition: ExprObjC.h:1329
#define false
Definition: stdbool.h:33
ObjCIndirectCopyRestoreExpr(Expr *operand, QualType type, bool shouldCopy)
Definition: ExprObjC.h:1534
Kind
static bool classof(const Stmt *T)
Definition: ExprObjC.h:108
bool isImplicitProperty() const
Definition: ExprObjC.h:667
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on a template...
Definition: Expr.h:190
Encodes a location in the source.
Selector getGetterSelector() const
Definition: ExprObjC.h:685
SourceLocation getEndLoc() const LLVM_READONLY
Definition: ExprObjC.h:363
ObjCSelectorExpr(EmptyShell Empty)
Definition: ExprObjC.h:439
SourceLocation getEndLoc() const LLVM_READONLY
Definition: ExprObjC.h:98
void setIsMessagingSetter(bool val=true)
Definition: ExprObjC.h:715
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c dictionary literal.
Definition: ExprObjC.h:342
ObjCMethodFamily getMethodFamily() const
Definition: ExprObjC.h:1322
SourceRange getSourceRange() const LLVM_READONLY
Definition: ExprObjC.h:364
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprObjC.h:450
static bool classof(const Stmt *T)
Definition: ExprObjC.h:164
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
Definition: Specifiers.h:124
void setClassReceiver(TypeSourceInfo *TSInfo)
Definition: ExprObjC.h:1241
SourceLocation getRParenLoc() const
Definition: ExprObjC.h:404
SourceLocation getSuperLoc() const
Retrieve the location of the &#39;super&#39; keyword for a class or instance message to &#39;super&#39;, otherwise an invalid source location.
Definition: ExprObjC.h:1248
SourceLocation getAtLoc() const
Definition: ExprObjC.h:402
SourceLocation getEndLoc() const LLVM_READONLY
Definition: ExprObjC.h:1484
SourceRange getSourceRange() const
Definition: ExprObjC.h:1659
void setIsFreeIvar(bool A)
Definition: ExprObjC.h:554
ObjCProtocolExpr used for protocol expression in Objective-C.
Definition: ExprObjC.h:474
SourceLocation getSelectorLoc(unsigned Index) const
Definition: ExprObjC.h:1372
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:148
bool hasVersion() const
This may be &#39;*&#39;, in which case this should fold to true.
Definition: ExprObjC.h:1662
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:721
const ObjCIvarDecl * getDecl() const
Definition: ExprObjC.h:544
bool isImplicit() const
Indicates whether the message send was implicitly generated by the implementation.
Definition: ExprObjC.h:1184
bool isMessagingGetter() const
True if the property reference will result in a message to the getter.
Definition: ExprObjC.h:700
void setBaseExpr(Stmt *S)
Definition: ExprObjC.h:849
Expr * getSubExpr()
Definition: ExprObjC.h:135
void setEncodedTypeSourceInfo(TypeSourceInfo *EncType)
Definition: ExprObjC.h:411
const ObjCMethodDecl * getMethodDecl() const
Definition: ExprObjC.h:1303
ObjCBoxedExpr - used for generalized expression boxing.
Definition: ExprObjC.h:117
static QualType getFromOpaquePtr(const void *Ptr)
Definition: Type.h:689
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprObjC.h:197
llvm::iterator_range< const_arg_iterator > arguments() const
Definition: ExprObjC.h:1412
A placeholder type used to construct an empty shell of a type, that will be filled in later (e...
Definition: Stmt.h:338
Expr * Value
The value of the dictionary element.
Definition: ExprObjC.h:244
Expr ** getElements()
Retrieve elements of array of literals.
Definition: ExprObjC.h:202
Defines various enumerations that describe declaration and type specifiers.
Expr * getInstanceReceiver()
Returns the object expression (receiver) for an instance message, or null for a message that is not a...
Definition: ExprObjC.h:1207
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprObjC.h:745
An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers...
Definition: ExprObjC.h:1575
arg_iterator arg_end()
Definition: ExprObjC.h:1418
Dataflow Directional Tag Classes.
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation getLocation() const
Definition: ExprObjC.h:726
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:355
void setAtLoc(SourceLocation L)
Definition: ExprObjC.h:496
QualType getSuperType() const
Retrieve the type referred to by &#39;super&#39;.
Definition: ExprObjC.h:1283
SourceLocation EllipsisLoc
The location of the ellipsis, if this is a pack expansion.
Definition: ExprObjC.h:247
void setDecl(ObjCIvarDecl *d)
Definition: ExprObjC.h:545
SourceLocation getEndLoc() const LLVM_READONLY
Definition: ExprObjC.h:562
A runtime availability query.
Definition: ExprObjC.h:1641
static bool classof(const Stmt *T)
Definition: ExprObjC.h:507
StmtClass getStmtClass() const
Definition: Stmt.h:391
child_range children()
Definition: ExprObjC.h:152
static bool classof(const Stmt *T)
Definition: ExprObjC.h:1623
ExplicitCastExpr - An explicit cast written in the source code.
Definition: Expr.h:3005
void setSelector(Selector S)
Definition: ExprObjC.h:1298
void setMethodDecl(ObjCMethodDecl *MD)
Definition: ExprObjC.h:1317
SourceLocation getLParenLoc() const
Definition: ExprObjC.h:1604
SourceLocation getRParenLoc() const
Definition: ExprObjC.h:495
child_range children()
Definition: ExprObjC.h:74
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprObjC.h:362
QualType getClassReceiver() const
Returns the type of a class message send, or NULL if the message is not a class message.
Definition: ExprObjC.h:1226
const_arg_iterator arg_begin() const
Definition: ExprObjC.h:156
SourceLocation getEndLoc() const LLVM_READONLY
Definition: ExprObjC.h:451
static bool classof(const Stmt *T)
Definition: ExprObjC.h:423
arg_iterator arg_begin()
Definition: ExprObjC.h:1416
SourceLocation getAtLoc() const
Definition: ExprObjC.h:142
Expr * getBase() const
Definition: ExprObjC.h:1463
SourceLocation getBeginLoc() const
Definition: ExprObjC.h:1657
ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter, QualType T, ExprValueKind VK, ExprObjectKind OK, SourceLocation IdLoc, SourceLocation SuperLoc, QualType SuperTy)
Definition: ExprObjC.h:644
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c array literal.
Definition: ExprObjC.h:210
child_range children()
Definition: ExprObjC.h:419
ObjCEncodeExpr, used for @encode in Objective-C.
Definition: ExprObjC.h:386
friend TrailingObjects
Definition: OpenMPClause.h:99
static bool classof(const Stmt *s)
Definition: ExprObjC.h:1564
SourceLocation getLocation() const
Definition: ExprObjC.h:556
ObjCAvailabilityCheckExpr(EmptyShell Shell)
Definition: ExprObjC.h:1654
ObjCBridgedCastExpr(SourceLocation LParenLoc, ObjCBridgeCastKind Kind, CastKind CK, SourceLocation BridgeKeywordLoc, TypeSourceInfo *TSInfo, Expr *Operand)
Definition: ExprObjC.h:1593
bool isDelegateInitCall() const
isDelegateInitCall - Answers whether this message send has been tagged as a "delegate init call"...
Definition: ExprObjC.h:1360
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition: ExprObjC.h:454
child_range children()
Definition: ExprObjC.h:1489
const Expr * getBase() const
Definition: ExprObjC.h:547
ObjCProtocolExpr(EmptyShell Empty)
Definition: ExprObjC.h:487
void setRParenLoc(SourceLocation L)
Definition: ExprObjC.h:405
A bitfield object is a bitfield on a C or C++ record.
Definition: Specifiers.h:129
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:513
SourceLocation getEndLoc() const LLVM_READONLY
Definition: ExprObjC.h:846
bool isFreeIvar() const
Definition: ExprObjC.h:552
QualType getSuperReceiverType() const
Definition: ExprObjC.h:730
Defines the clang::SourceLocation class and associated facilities.
llvm::iterator_range< arg_iterator > arguments()
Definition: ExprObjC.h:1408
void setSourceRange(SourceRange R)
Definition: ExprObjC.h:1394
SourceLocation getSelectorStartLoc() const
Definition: ExprObjC.h:1366
SourceLocation getEndLoc() const LLVM_READONLY
Definition: ExprObjC.h:1556
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprObjC.h:1399
bool isPackExpansion() const
Determines whether this dictionary element is a pack expansion.
Definition: ExprObjC.h:254
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1937
void setIsaMemberLoc(SourceLocation L)
Definition: ExprObjC.h:1471
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates)...
Definition: Expr.h:213
bool shouldCopy() const
shouldCopy - True if we should do the &#39;copy&#39; part of the copy-restore.
Definition: ExprObjC.h:1548
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1573
void setOpLoc(SourceLocation L)
Definition: ExprObjC.h:565
const Expr * getArg(unsigned Arg) const
Definition: ExprObjC.h:1346
Internal struct to describes an element that is a pack expansion, used if any of the elements in the ...
Definition: ExprObjC.h:276
static bool classof(const Stmt *T)
Definition: ExprObjC.h:76
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
Definition: ExprObjC.h:82
bool isObjectReceiver() const
Definition: ExprObjC.h:738
SourceLocation getReceiverLocation() const
Definition: ExprObjC.h:728
SourceLocation getBridgeKeywordLoc() const
The location of the bridge keyword.
Definition: ExprObjC.h:1615
ObjCProtocolExpr(QualType T, ObjCProtocolDecl *protocol, SourceLocation at, SourceLocation protoLoc, SourceLocation rp)
Definition: ExprObjC.h:482
const Expr * getSubExpr() const
Definition: ExprObjC.h:1544
bool isArraySubscriptRefExpr() const
Definition: ExprObjC.h:862
#define true
Definition: stdbool.h:32
static bool classof(const Stmt *T)
Definition: ExprObjC.h:232
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:114
const Expr * getBase() const
Definition: ExprObjC.h:719
A trivial tuple used to represent a source range.
ObjCMethodDecl * getMethodDecl()
Definition: ExprObjC.h:1310
SourceLocation getEndLoc() const LLVM_READONLY
Definition: ExprObjC.h:416
SourceLocation getRightLoc() const
Definition: ExprObjC.h:1364
The receiver is a superclass.
Definition: ExprObjC.h:1058
bool isInstanceMessage() const
Determine whether this is an instance message to either a computed object or to super.
Definition: ExprObjC.h:1195
SourceLocation getBegin() const
static bool classof(const Stmt *T)
Definition: ExprObjC.h:1669
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
Definition: ExprObjC.h:1352
void setBase(Expr *E)
Definition: ExprObjC.h:1462
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprObjC.h:559
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprObjC.h:70
const Expr * getSubExpr() const
Definition: ExprObjC.h:136
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:97
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, ArrayRef< Expr *> PL, ArrayRef< Expr *> IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
child_range children()
Definition: ExprObjC.h:503
TypeSourceInfo * getClassReceiverTypeInfo() const
Returns a type-source information of a class message send, or nullptr if the message is not a class m...
Definition: ExprObjC.h:1235