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