1 //===- ExprObjC.h - Classes for representing ObjC expressions ---*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
9 // This file defines the ExprObjC interface and subclasses.
11 //===----------------------------------------------------------------------===//
13 #ifndef LLVM_CLANG_AST_EXPROBJC_H
14 #define LLVM_CLANG_AST_EXPROBJC_H
16 #include "clang/AST/ComputeDependence.h"
17 #include "clang/AST/Decl.h"
18 #include "clang/AST/DeclObjC.h"
19 #include "clang/AST/DependenceFlags.h"
20 #include "clang/AST/Expr.h"
21 #include "clang/AST/OperationKinds.h"
22 #include "clang/AST/SelectorLocationsKind.h"
23 #include "clang/AST/Stmt.h"
24 #include "clang/AST/Type.h"
25 #include "clang/Basic/IdentifierTable.h"
26 #include "clang/Basic/LLVM.h"
27 #include "clang/Basic/SourceLocation.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"
48 class CXXBaseSpecifier;
50 /// ObjCStringLiteral, used for Objective-C string literals
52 class ObjCStringLiteral : public Expr {
57 ObjCStringLiteral(StringLiteral *SL, QualType T, SourceLocation L)
58 : Expr(ObjCStringLiteralClass, T, VK_PRValue, OK_Ordinary), String(SL),
60 setDependence(ExprDependence::None);
62 explicit ObjCStringLiteral(EmptyShell Empty)
63 : Expr(ObjCStringLiteralClass, Empty) {}
65 StringLiteral *getString() { return cast<StringLiteral>(String); }
66 const StringLiteral *getString() const { return cast<StringLiteral>(String); }
67 void setString(StringLiteral *S) { String = S; }
69 SourceLocation getAtLoc() const { return AtLoc; }
70 void setAtLoc(SourceLocation L) { AtLoc = L; }
72 SourceLocation getBeginLoc() const LLVM_READONLY { return AtLoc; }
73 SourceLocation getEndLoc() const LLVM_READONLY { return String->getEndLoc(); }
76 child_range children() { return child_range(&String, &String+1); }
78 const_child_range children() const {
79 return const_child_range(&String, &String + 1);
82 static bool classof(const Stmt *T) {
83 return T->getStmtClass() == ObjCStringLiteralClass;
87 /// ObjCBoolLiteralExpr - Objective-C Boolean Literal.
88 class ObjCBoolLiteralExpr : public Expr {
93 ObjCBoolLiteralExpr(bool val, QualType Ty, SourceLocation l)
94 : Expr(ObjCBoolLiteralExprClass, Ty, VK_PRValue, OK_Ordinary), Value(val),
96 setDependence(ExprDependence::None);
98 explicit ObjCBoolLiteralExpr(EmptyShell Empty)
99 : Expr(ObjCBoolLiteralExprClass, Empty) {}
101 bool getValue() const { return Value; }
102 void setValue(bool V) { Value = V; }
104 SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
105 SourceLocation getEndLoc() const LLVM_READONLY { return Loc; }
107 SourceLocation getLocation() const { return Loc; }
108 void setLocation(SourceLocation L) { Loc = L; }
111 child_range children() {
112 return child_range(child_iterator(), child_iterator());
115 const_child_range children() const {
116 return const_child_range(const_child_iterator(), const_child_iterator());
119 static bool classof(const Stmt *T) {
120 return T->getStmtClass() == ObjCBoolLiteralExprClass;
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 {
130 ObjCMethodDecl *BoxingMethod;
134 friend class ASTStmtReader;
136 ObjCBoxedExpr(Expr *E, QualType T, ObjCMethodDecl *method, SourceRange R)
137 : Expr(ObjCBoxedExprClass, T, VK_PRValue, OK_Ordinary), SubExpr(E),
138 BoxingMethod(method), Range(R) {
139 setDependence(computeDependence(this));
141 explicit ObjCBoxedExpr(EmptyShell Empty)
142 : Expr(ObjCBoxedExprClass, Empty) {}
144 Expr *getSubExpr() { return cast<Expr>(SubExpr); }
145 const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
147 ObjCMethodDecl *getBoxingMethod() const {
151 // Indicates whether this boxed expression can be emitted as a compile-time
153 bool isExpressibleAsConstantInitializer() const {
154 return !BoxingMethod && SubExpr;
157 SourceLocation getAtLoc() const { return Range.getBegin(); }
159 SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); }
160 SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); }
162 SourceRange getSourceRange() const LLVM_READONLY {
167 child_range children() { return child_range(&SubExpr, &SubExpr+1); }
169 const_child_range children() const {
170 return const_child_range(&SubExpr, &SubExpr + 1);
173 using const_arg_iterator = ConstExprIterator;
175 const_arg_iterator arg_begin() const {
176 return reinterpret_cast<Stmt const * const*>(&SubExpr);
179 const_arg_iterator arg_end() const {
180 return reinterpret_cast<Stmt const * const*>(&SubExpr + 1);
183 static bool classof(const Stmt *T) {
184 return T->getStmtClass() == ObjCBoxedExprClass;
188 /// ObjCArrayLiteral - used for objective-c array containers; as in:
189 /// @[@"Hello", NSApp, [NSNumber numberWithInt:42]];
190 class ObjCArrayLiteral final
192 private llvm::TrailingObjects<ObjCArrayLiteral, Expr *> {
193 unsigned NumElements;
195 ObjCMethodDecl *ArrayWithObjectsMethod;
197 ObjCArrayLiteral(ArrayRef<Expr *> Elements,
198 QualType T, ObjCMethodDecl * Method,
201 explicit ObjCArrayLiteral(EmptyShell Empty, unsigned NumElements)
202 : Expr(ObjCArrayLiteralClass, Empty), NumElements(NumElements) {}
205 friend class ASTStmtReader;
206 friend TrailingObjects;
208 static ObjCArrayLiteral *Create(const ASTContext &C,
209 ArrayRef<Expr *> Elements,
210 QualType T, ObjCMethodDecl * Method,
213 static ObjCArrayLiteral *CreateEmpty(const ASTContext &C,
214 unsigned NumElements);
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; }
220 /// Retrieve elements of array of literals.
221 Expr **getElements() { return getTrailingObjects<Expr *>(); }
223 /// Retrieve elements of array of literals.
224 const Expr * const *getElements() const {
225 return getTrailingObjects<Expr *>();
228 /// getNumElements - Return number of elements of objective-c array literal.
229 unsigned getNumElements() const { return NumElements; }
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];
236 const Expr *getElement(unsigned Index) const {
237 assert((Index < NumElements) && "Arg access out of range!");
238 return getElements()[Index];
241 ObjCMethodDecl *getArrayWithObjectsMethod() const {
242 return ArrayWithObjectsMethod;
246 child_range children() {
247 return child_range(reinterpret_cast<Stmt **>(getElements()),
248 reinterpret_cast<Stmt **>(getElements()) + NumElements);
251 const_child_range children() const {
252 auto Children = const_cast<ObjCArrayLiteral *>(this)->children();
253 return const_child_range(Children.begin(), Children.end());
256 static bool classof(const Stmt *T) {
257 return T->getStmtClass() == ObjCArrayLiteralClass;
261 /// An element in an Objective-C dictionary literal.
263 struct ObjCDictionaryElement {
264 /// The key for the dictionary element.
267 /// The value of the dictionary element.
270 /// The location of the ellipsis, if this is a pack expansion.
271 SourceLocation EllipsisLoc;
273 /// The number of elements this pack expansion will expand to, if
274 /// this is a pack expansion and is known.
275 Optional<unsigned> NumExpansions;
277 /// Determines whether this dictionary element is a pack expansion.
278 bool isPackExpansion() const { return EllipsisLoc.isValid(); }
285 /// Internal struct for storing Key/value pair.
286 struct ObjCDictionaryLiteral_KeyValuePair {
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.
294 struct ObjCDictionaryLiteral_ExpansionData {
295 /// The location of the ellipsis, if this element is a pack
297 SourceLocation EllipsisLoc;
299 /// If non-zero, the number of elements that this pack
300 /// expansion will expand to (+1).
301 unsigned NumExpansionsPlusOne;
304 /// ObjCDictionaryLiteral - AST node to represent objective-c dictionary
305 /// literals; as in: @{@"name" : NSUserName(), @"date" : [NSDate date] };
306 class ObjCDictionaryLiteral final
308 private llvm::TrailingObjects<ObjCDictionaryLiteral,
309 ObjCDictionaryLiteral_KeyValuePair,
310 ObjCDictionaryLiteral_ExpansionData> {
311 /// The number of elements in this dictionary literal.
312 unsigned NumElements : 31;
314 /// Determine whether this dictionary literal has any pack expansions.
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;
324 ObjCMethodDecl *DictWithObjectsMethod;
326 using KeyValuePair = ObjCDictionaryLiteral_KeyValuePair;
327 using ExpansionData = ObjCDictionaryLiteral_ExpansionData;
329 ObjCDictionaryLiteral(ArrayRef<ObjCDictionaryElement> VK,
330 bool HasPackExpansions,
331 QualType T, ObjCMethodDecl *method,
334 explicit ObjCDictionaryLiteral(EmptyShell Empty, unsigned NumElements,
335 bool HasPackExpansions)
336 : Expr(ObjCDictionaryLiteralClass, Empty), NumElements(NumElements),
337 HasPackExpansions(HasPackExpansions) {}
339 size_t numTrailingObjects(OverloadToken<KeyValuePair>) const {
344 friend class ASTStmtReader;
345 friend class ASTStmtWriter;
346 friend TrailingObjects;
348 static ObjCDictionaryLiteral *Create(const ASTContext &C,
349 ArrayRef<ObjCDictionaryElement> VK,
350 bool HasPackExpansions,
351 QualType T, ObjCMethodDecl *method,
354 static ObjCDictionaryLiteral *CreateEmpty(const ASTContext &C,
355 unsigned NumElements,
356 bool HasPackExpansions);
358 /// getNumElements - Return number of elements of objective-c dictionary
360 unsigned getNumElements() const { return NumElements; }
362 ObjCDictionaryElement getKeyValueElement(unsigned Index) const {
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;
376 ObjCMethodDecl *getDictWithObjectsMethod() const {
377 return DictWithObjectsMethod;
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; }
385 child_range children() {
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");
391 reinterpret_cast<Stmt **>(getTrailingObjects<KeyValuePair>()),
392 reinterpret_cast<Stmt **>(getTrailingObjects<KeyValuePair>()) +
396 const_child_range children() const {
397 auto Children = const_cast<ObjCDictionaryLiteral *>(this)->children();
398 return const_child_range(Children.begin(), Children.end());
401 static bool classof(const Stmt *T) {
402 return T->getStmtClass() == ObjCDictionaryLiteralClass;
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;
414 ObjCEncodeExpr(QualType T, TypeSourceInfo *EncodedType, SourceLocation at,
416 : Expr(ObjCEncodeExprClass, T, VK_LValue, OK_Ordinary),
417 EncodedType(EncodedType), AtLoc(at), RParenLoc(rp) {
418 setDependence(computeDependence(this));
421 explicit ObjCEncodeExpr(EmptyShell Empty) : Expr(ObjCEncodeExprClass, Empty){}
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; }
428 QualType getEncodedType() const { return EncodedType->getType(); }
430 TypeSourceInfo *getEncodedTypeSourceInfo() const { return EncodedType; }
432 void setEncodedTypeSourceInfo(TypeSourceInfo *EncType) {
433 EncodedType = EncType;
436 SourceLocation getBeginLoc() const LLVM_READONLY { return AtLoc; }
437 SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
440 child_range children() {
441 return child_range(child_iterator(), child_iterator());
444 const_child_range children() const {
445 return const_child_range(const_child_iterator(), const_child_iterator());
448 static bool classof(const Stmt *T) {
449 return T->getStmtClass() == ObjCEncodeExprClass;
453 /// ObjCSelectorExpr used for \@selector in Objective-C.
454 class ObjCSelectorExpr : public Expr {
456 SourceLocation AtLoc, RParenLoc;
459 ObjCSelectorExpr(QualType T, Selector selInfo, SourceLocation at,
461 : Expr(ObjCSelectorExprClass, T, VK_PRValue, OK_Ordinary),
462 SelName(selInfo), AtLoc(at), RParenLoc(rp) {
463 setDependence(ExprDependence::None);
465 explicit ObjCSelectorExpr(EmptyShell Empty)
466 : Expr(ObjCSelectorExprClass, Empty) {}
468 Selector getSelector() const { return SelName; }
469 void setSelector(Selector S) { SelName = S; }
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; }
476 SourceLocation getBeginLoc() const LLVM_READONLY { return AtLoc; }
477 SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
479 /// getNumArgs - Return the number of actual arguments to this call.
480 unsigned getNumArgs() const { return SelName.getNumArgs(); }
483 child_range children() {
484 return child_range(child_iterator(), child_iterator());
487 const_child_range children() const {
488 return const_child_range(const_child_iterator(), const_child_iterator());
491 static bool classof(const Stmt *T) {
492 return T->getStmtClass() == ObjCSelectorExprClass;
496 /// ObjCProtocolExpr used for protocol expression in Objective-C.
498 /// This is used as: \@protocol(foo), as in:
500 /// [obj conformsToProtocol:@protocol(foo)]
503 /// The return type is "Protocol*".
504 class ObjCProtocolExpr : public Expr {
505 ObjCProtocolDecl *TheProtocol;
506 SourceLocation AtLoc, ProtoLoc, RParenLoc;
509 friend class ASTStmtReader;
510 friend class ASTStmtWriter;
512 ObjCProtocolExpr(QualType T, ObjCProtocolDecl *protocol, SourceLocation at,
513 SourceLocation protoLoc, SourceLocation rp)
514 : Expr(ObjCProtocolExprClass, T, VK_PRValue, OK_Ordinary),
515 TheProtocol(protocol), AtLoc(at), ProtoLoc(protoLoc), RParenLoc(rp) {
516 setDependence(ExprDependence::None);
518 explicit ObjCProtocolExpr(EmptyShell Empty)
519 : Expr(ObjCProtocolExprClass, Empty) {}
521 ObjCProtocolDecl *getProtocol() const { return TheProtocol; }
522 void setProtocol(ObjCProtocolDecl *P) { TheProtocol = P; }
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; }
530 SourceLocation getBeginLoc() const LLVM_READONLY { return AtLoc; }
531 SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
534 child_range children() {
535 return child_range(child_iterator(), child_iterator());
538 const_child_range children() const {
539 return const_child_range(const_child_iterator(), const_child_iterator());
542 static bool classof(const Stmt *T) {
543 return T->getStmtClass() == ObjCProtocolExprClass;
547 /// ObjCIvarRefExpr - A reference to an ObjC instance variable.
548 class ObjCIvarRefExpr : public Expr {
553 /// OpLoc - This is the location of '.' or '->'
554 SourceLocation OpLoc;
556 // True if this is "X->F", false if this is "X.F".
559 // True if ivar reference has no base (self assumed).
563 ObjCIvarRefExpr(ObjCIvarDecl *d, QualType t, SourceLocation l,
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) {
570 setDependence(computeDependence(this));
573 explicit ObjCIvarRefExpr(EmptyShell Empty)
574 : Expr(ObjCIvarRefExprClass, Empty) {}
576 ObjCIvarDecl *getDecl() { return D; }
577 const ObjCIvarDecl *getDecl() const { return D; }
578 void setDecl(ObjCIvarDecl *d) { D = d; }
580 const Expr *getBase() const { return cast<Expr>(Base); }
581 Expr *getBase() { return cast<Expr>(Base); }
582 void setBase(Expr * base) { Base = base; }
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; }
589 SourceLocation getLocation() const { return Loc; }
590 void setLocation(SourceLocation L) { Loc = L; }
592 SourceLocation getBeginLoc() const LLVM_READONLY {
593 return isFreeIvar() ? Loc : getBase()->getBeginLoc();
595 SourceLocation getEndLoc() const LLVM_READONLY { return Loc; }
597 SourceLocation getOpLoc() const { return OpLoc; }
598 void setOpLoc(SourceLocation L) { OpLoc = L; }
601 child_range children() { return child_range(&Base, &Base+1); }
603 const_child_range children() const {
604 return const_child_range(&Base, &Base + 1);
607 static bool classof(const Stmt *T) {
608 return T->getStmtClass() == ObjCIvarRefExprClass;
612 /// ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC
614 class ObjCPropertyRefExpr : public Expr {
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;
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 {
627 MethodRef_Getter = 0x1,
628 MethodRef_Setter = 0x2
631 /// Contains the Setter method pointer and MethodRefFlags bit flags.
632 llvm::PointerIntPair<ObjCMethodDecl *, 2, unsigned> SetterAndMethodRefFlags;
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).
639 SourceLocation IdLoc;
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;
648 ObjCPropertyRefExpr(ObjCPropertyDecl *PD, QualType t, ExprValueKind VK,
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));
653 setDependence(computeDependence(this));
656 ObjCPropertyRefExpr(ObjCPropertyDecl *PD, QualType t, ExprValueKind VK,
657 ExprObjectKind OK, SourceLocation l, SourceLocation sl,
659 : Expr(ObjCPropertyRefExprClass, t, VK, OK), PropertyOrGetter(PD, false),
660 IdLoc(l), ReceiverLoc(sl), Receiver(st.getTypePtr()) {
661 assert(t->isSpecificPlaceholderType(BuiltinType::PseudoObject));
662 setDependence(computeDependence(this));
665 ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter,
666 QualType T, ExprValueKind VK, ExprObjectKind OK,
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));
672 setDependence(computeDependence(this));
675 ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter,
676 QualType T, ExprValueKind VK, ExprObjectKind OK,
677 SourceLocation IdLoc, SourceLocation SuperLoc,
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));
683 setDependence(computeDependence(this));
686 ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter,
687 QualType T, ExprValueKind VK, ExprObjectKind OK,
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));
694 setDependence(computeDependence(this));
697 explicit ObjCPropertyRefExpr(EmptyShell Empty)
698 : Expr(ObjCPropertyRefExprClass, Empty) {}
700 bool isImplicitProperty() const { return PropertyOrGetter.getInt(); }
701 bool isExplicitProperty() const { return !PropertyOrGetter.getInt(); }
703 ObjCPropertyDecl *getExplicitProperty() const {
704 assert(!isImplicitProperty());
705 return cast<ObjCPropertyDecl>(PropertyOrGetter.getPointer());
708 ObjCMethodDecl *getImplicitPropertyGetter() const {
709 assert(isImplicitProperty());
710 return cast_or_null<ObjCMethodDecl>(PropertyOrGetter.getPointer());
713 ObjCMethodDecl *getImplicitPropertySetter() const {
714 assert(isImplicitProperty());
715 return SetterAndMethodRefFlags.getPointer();
718 Selector getGetterSelector() const {
719 if (isImplicitProperty())
720 return getImplicitPropertyGetter()->getSelector();
721 return getExplicitProperty()->getGetterName();
724 Selector getSetterSelector() const {
725 if (isImplicitProperty())
726 return getImplicitPropertySetter()->getSelector();
727 return getExplicitProperty()->getSetterName();
730 /// True if the property reference will result in a message to the
732 /// This applies to both implicit and explicit property references.
733 bool isMessagingGetter() const {
734 return SetterAndMethodRefFlags.getInt() & MethodRef_Getter;
737 /// True if the property reference will result in a message to the
739 /// This applies to both implicit and explicit property references.
740 bool isMessagingSetter() const {
741 return SetterAndMethodRefFlags.getInt() & MethodRef_Setter;
744 void setIsMessagingGetter(bool val = true) {
745 setMethodRefFlag(MethodRef_Getter, val);
748 void setIsMessagingSetter(bool val = true) {
749 setMethodRefFlag(MethodRef_Setter, val);
752 const Expr *getBase() const {
753 return cast<Expr>(Receiver.get<Stmt*>());
756 return cast<Expr>(Receiver.get<Stmt*>());
759 SourceLocation getLocation() const { return IdLoc; }
761 SourceLocation getReceiverLocation() const { return ReceiverLoc; }
763 QualType getSuperReceiverType() const {
764 return QualType(Receiver.get<const Type*>(), 0);
767 ObjCInterfaceDecl *getClassReceiver() const {
768 return Receiver.get<ObjCInterfaceDecl*>();
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*>(); }
775 /// Determine the type of the base, regardless of the kind of receiver.
776 QualType getReceiverType(const ASTContext &ctx) const;
778 SourceLocation getBeginLoc() const LLVM_READONLY {
779 return isObjectReceiver() ? getBase()->getBeginLoc()
780 : getReceiverLocation();
783 SourceLocation getEndLoc() const LLVM_READONLY { return IdLoc; }
786 child_range children() {
787 if (Receiver.is<Stmt*>()) {
788 Stmt **begin = reinterpret_cast<Stmt**>(&Receiver); // hack!
789 return child_range(begin, begin+1);
791 return child_range(child_iterator(), child_iterator());
794 const_child_range children() const {
795 auto Children = const_cast<ObjCPropertyRefExpr *>(this)->children();
796 return const_child_range(Children.begin(), Children.end());
799 static bool classof(const Stmt *T) {
800 return T->getStmtClass() == ObjCPropertyRefExprClass;
804 friend class ASTStmtReader;
805 friend class ASTStmtWriter;
807 void setExplicitProperty(ObjCPropertyDecl *D, unsigned methRefFlags) {
808 PropertyOrGetter.setPointer(D);
809 PropertyOrGetter.setInt(false);
810 SetterAndMethodRefFlags.setPointer(nullptr);
811 SetterAndMethodRefFlags.setInt(methRefFlags);
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);
822 void setBase(Expr *Base) { Receiver = Base; }
823 void setSuperReceiver(QualType T) { Receiver = T.getTypePtr(); }
824 void setClassReceiver(ObjCInterfaceDecl *D) { Receiver = D; }
826 void setLocation(SourceLocation L) { IdLoc = L; }
827 void setReceiverLocation(SourceLocation Loc) { ReceiverLoc = Loc; }
829 void setMethodRefFlag(MethodRefFlags flag, bool val) {
830 unsigned f = SetterAndMethodRefFlags.getInt();
835 SetterAndMethodRefFlags.setInt(f);
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;
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];
851 ObjCMethodDecl *GetAtIndexMethodDecl;
853 // For immutable objects this is null. When ObjCSubscriptRefExpr is to read
854 // an indexed object this is null too.
855 ObjCMethodDecl *SetAtIndexMethodDecl;
858 ObjCSubscriptRefExpr(Expr *base, Expr *key, QualType T, ExprValueKind VK,
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;
865 setDependence(computeDependence(this));
868 explicit ObjCSubscriptRefExpr(EmptyShell Empty)
869 : Expr(ObjCSubscriptRefExprClass, Empty) {}
871 SourceLocation getRBracket() const { return RBracket; }
872 void setRBracket(SourceLocation RB) { RBracket = RB; }
874 SourceLocation getBeginLoc() const LLVM_READONLY {
875 return SubExprs[BASE]->getBeginLoc();
878 SourceLocation getEndLoc() const LLVM_READONLY { return RBracket; }
880 Expr *getBaseExpr() const { return cast<Expr>(SubExprs[BASE]); }
881 void setBaseExpr(Stmt *S) { SubExprs[BASE] = S; }
883 Expr *getKeyExpr() const { return cast<Expr>(SubExprs[KEY]); }
884 void setKeyExpr(Stmt *S) { SubExprs[KEY] = S; }
886 ObjCMethodDecl *getAtIndexMethodDecl() const {
887 return GetAtIndexMethodDecl;
890 ObjCMethodDecl *setAtIndexMethodDecl() const {
891 return SetAtIndexMethodDecl;
894 bool isArraySubscriptRefExpr() const {
895 return getKeyExpr()->getType()->isIntegralOrEnumerationType();
898 child_range children() {
899 return child_range(SubExprs, SubExprs+END_EXPR);
902 const_child_range children() const {
903 return const_child_range(SubExprs, SubExprs + END_EXPR);
906 static bool classof(const Stmt *T) {
907 return T->getStmtClass() == ObjCSubscriptRefExprClass;
911 friend class ASTStmtReader;
914 /// An expression that sends a message to the given Objective-C
917 /// The following contains two message send expressions:
920 /// [[NSString alloc] initWithString:@"Hello"]
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:
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.
934 /// All four kinds of message sends are modeled by the ObjCMessageExpr
935 /// class, and can be distinguished via \c getReceiverKind(). Example:
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
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;
948 enum { NumArgsBitWidth = 16 };
950 /// The number of arguments in the message send, not
951 /// including the receiver.
952 unsigned NumArgs : NumArgsBitWidth;
954 /// The kind of message send this is, which is one of the
955 /// ReceiverKind values.
957 /// We pad this out to a byte to avoid excessive masking and shifting.
960 /// Whether we have an actual method prototype in \c
961 /// SelectorOrMethod.
963 /// When non-zero, we have a method declaration; otherwise, we just
965 unsigned HasMethod : 1;
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;
971 /// Whether this message send was implicitly generated by
972 /// the implementation rather than explicitly written by the user.
973 unsigned IsImplicit : 1;
975 /// Whether the locations of the selector identifiers are in a
976 /// "standard" position, a enum SelectorLocationsKind.
977 unsigned SelLocsKind : 2;
979 /// When the message expression is a send to 'super', this is
980 /// the location of the 'super' keyword.
981 SourceLocation SuperLoc;
983 /// The source locations of the open and close square
984 /// brackets ('[' and ']', respectively).
985 SourceLocation LBracLoc, RBracLoc;
987 ObjCMessageExpr(EmptyShell Empty, unsigned NumArgs)
988 : Expr(ObjCMessageExprClass, Empty), Kind(0), HasMethod(false),
989 IsDelegateInitCall(false), IsImplicit(false), SelLocsKind(0) {
993 ObjCMessageExpr(QualType T, ExprValueKind VK,
994 SourceLocation LBracLoc,
995 SourceLocation SuperLoc,
996 bool IsInstanceSuper,
999 ArrayRef<SourceLocation> SelLocs,
1000 SelectorLocationsKind SelLocsK,
1001 ObjCMethodDecl *Method,
1002 ArrayRef<Expr *> Args,
1003 SourceLocation RBracLoc,
1005 ObjCMessageExpr(QualType T, ExprValueKind VK,
1006 SourceLocation LBracLoc,
1007 TypeSourceInfo *Receiver,
1009 ArrayRef<SourceLocation> SelLocs,
1010 SelectorLocationsKind SelLocsK,
1011 ObjCMethodDecl *Method,
1012 ArrayRef<Expr *> Args,
1013 SourceLocation RBracLoc,
1015 ObjCMessageExpr(QualType T, ExprValueKind VK,
1016 SourceLocation LBracLoc,
1019 ArrayRef<SourceLocation> SelLocs,
1020 SelectorLocationsKind SelLocsK,
1021 ObjCMethodDecl *Method,
1022 ArrayRef<Expr *> Args,
1023 SourceLocation RBracLoc,
1026 size_t numTrailingObjects(OverloadToken<void *>) const { return NumArgs + 1; }
1028 void setNumArgs(unsigned Num) {
1029 assert((Num >> NumArgsBitWidth) == 0 && "Num of args is out of range!");
1033 void initArgsAndSelLocs(ArrayRef<Expr *> Args,
1034 ArrayRef<SourceLocation> SelLocs,
1035 SelectorLocationsKind SelLocsK);
1037 /// Retrieve the pointer value of the message receiver.
1038 void *getReceiverPointer() const { return *getTrailingObjects<void *>(); }
1040 /// Set the pointer value of the message receiver.
1041 void setReceiverPointer(void *Value) {
1042 *getTrailingObjects<void *>() = Value;
1045 SelectorLocationsKind getSelLocsKind() const {
1046 return (SelectorLocationsKind)SelLocsKind;
1049 bool hasStandardSelLocs() const {
1050 return getSelLocsKind() != SelLoc_NonStandard;
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>();
1058 const SourceLocation *getStoredSelLocs() const {
1059 return getTrailingObjects<SourceLocation>();
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())
1067 return getNumSelectorLocs();
1070 static ObjCMessageExpr *alloc(const ASTContext &C,
1071 ArrayRef<Expr *> Args,
1072 SourceLocation RBraceLoc,
1073 ArrayRef<SourceLocation> SelLocs,
1075 SelectorLocationsKind &SelLocsK);
1076 static ObjCMessageExpr *alloc(const ASTContext &C,
1078 unsigned NumStoredSelLocs);
1081 friend class ASTStmtReader;
1082 friend class ASTStmtWriter;
1083 friend TrailingObjects;
1085 /// The kind of receiver this message is sending to.
1087 /// The receiver is a class.
1090 /// The receiver is an object instance.
1093 /// The receiver is a superclass.
1096 /// The receiver is the instance of the superclass object.
1100 /// Create a message send to super.
1102 /// \param Context The ASTContext in which this expression will be created.
1104 /// \param T The result type of this message.
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,
1110 /// \param LBracLoc The location of the open square bracket '['.
1112 /// \param SuperLoc The location of the "super" keyword.
1114 /// \param IsInstanceSuper Whether this is an instance "super"
1115 /// message (otherwise, it's a class "super" message).
1117 /// \param Sel The selector used to determine which method gets called.
1119 /// \param Method The Objective-C method against which this message
1120 /// send was type-checked. May be nullptr.
1122 /// \param Args The message send arguments.
1124 /// \param RBracLoc The location of the closing square bracket ']'.
1125 static ObjCMessageExpr *Create(const ASTContext &Context, QualType T,
1127 SourceLocation LBracLoc,
1128 SourceLocation SuperLoc,
1129 bool IsInstanceSuper,
1132 ArrayRef<SourceLocation> SelLocs,
1133 ObjCMethodDecl *Method,
1134 ArrayRef<Expr *> Args,
1135 SourceLocation RBracLoc,
1138 /// Create a class message send.
1140 /// \param Context The ASTContext in which this expression will be created.
1142 /// \param T The result type of this message.
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,
1148 /// \param LBracLoc The location of the open square bracket '['.
1150 /// \param Receiver The type of the receiver, including
1151 /// source-location information.
1153 /// \param Sel The selector used to determine which method gets called.
1155 /// \param Method The Objective-C method against which this message
1156 /// send was type-checked. May be nullptr.
1158 /// \param Args The message send arguments.
1160 /// \param RBracLoc The location of the closing square bracket ']'.
1161 static ObjCMessageExpr *Create(const ASTContext &Context, QualType T,
1163 SourceLocation LBracLoc,
1164 TypeSourceInfo *Receiver,
1166 ArrayRef<SourceLocation> SelLocs,
1167 ObjCMethodDecl *Method,
1168 ArrayRef<Expr *> Args,
1169 SourceLocation RBracLoc,
1172 /// Create an instance message send.
1174 /// \param Context The ASTContext in which this expression will be created.
1176 /// \param T The result type of this message.
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,
1182 /// \param LBracLoc The location of the open square bracket '['.
1184 /// \param Receiver The expression used to produce the object that
1185 /// will receive this message.
1187 /// \param Sel The selector used to determine which method gets called.
1189 /// \param Method The Objective-C method against which this message
1190 /// send was type-checked. May be nullptr.
1192 /// \param Args The message send arguments.
1194 /// \param RBracLoc The location of the closing square bracket ']'.
1195 static ObjCMessageExpr *Create(const ASTContext &Context, QualType T,
1197 SourceLocation LBracLoc,
1200 ArrayRef<SourceLocation> SeLocs,
1201 ObjCMethodDecl *Method,
1202 ArrayRef<Expr *> Args,
1203 SourceLocation RBracLoc,
1206 /// Create an empty Objective-C message expression, to be
1207 /// filled in by subsequent calls.
1209 /// \param Context The context in which the message send will be created.
1211 /// \param NumArgs The number of message arguments, not including
1213 static ObjCMessageExpr *CreateEmpty(const ASTContext &Context,
1215 unsigned NumStoredSelLocs);
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; }
1222 /// Determine the kind of receiver that this message is being
1224 ReceiverKind getReceiverKind() const { return (ReceiverKind)Kind; }
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).
1231 QualType getCallReturnType(ASTContext &Ctx) const;
1233 /// Source range of the receiver.
1234 SourceRange getReceiverRange() const;
1236 /// Determine whether this is an instance message to either a
1237 /// computed object or to super.
1238 bool isInstanceMessage() const {
1239 return getReceiverKind() == Instance || getReceiverKind() == SuperInstance;
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;
1248 /// Returns the object expression (receiver) for an instance message,
1249 /// or null for a message that is not an instance message.
1250 Expr *getInstanceReceiver() {
1251 if (getReceiverKind() == Instance)
1252 return static_cast<Expr *>(getReceiverPointer());
1256 const Expr *getInstanceReceiver() const {
1257 return const_cast<ObjCMessageExpr*>(this)->getInstanceReceiver();
1260 /// Turn this message send into an instance message that
1261 /// computes the receiver object with the given expression.
1262 void setInstanceReceiver(Expr *rec) {
1264 setReceiverPointer(rec);
1267 /// Returns the type of a class message send, or NULL if the
1268 /// message is not a class message.
1269 QualType getClassReceiver() const {
1270 if (TypeSourceInfo *TSInfo = getClassReceiverTypeInfo())
1271 return TSInfo->getType();
1276 /// Returns a type-source information of a class message
1277 /// send, or nullptr if the message is not a class message.
1278 TypeSourceInfo *getClassReceiverTypeInfo() const {
1279 if (getReceiverKind() == Class)
1280 return reinterpret_cast<TypeSourceInfo *>(getReceiverPointer());
1284 void setClassReceiver(TypeSourceInfo *TSInfo) {
1286 setReceiverPointer(TSInfo);
1289 /// Retrieve the location of the 'super' keyword for a class
1290 /// or instance message to 'super', otherwise an invalid source location.
1291 SourceLocation getSuperLoc() const {
1292 if (getReceiverKind() == SuperInstance || getReceiverKind() == SuperClass)
1295 return SourceLocation();
1298 /// Retrieve the receiver type to which this message is being directed.
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.
1306 /// \returns The type of the receiver.
1307 QualType getReceiverType() const;
1309 /// Retrieve the Objective-C interface to which this message
1310 /// is being directed, if known.
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.
1318 /// \returns The Objective-C interface if known, otherwise nullptr.
1319 ObjCInterfaceDecl *getReceiverInterface() const;
1321 /// Retrieve the type referred to by 'super'.
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);
1326 QualType getSuperType() const {
1327 if (getReceiverKind() == SuperInstance || getReceiverKind() == SuperClass)
1328 return QualType::getFromOpaquePtr(getReceiverPointer());
1333 void setSuper(SourceLocation Loc, QualType T, bool IsInstanceSuper) {
1334 Kind = IsInstanceSuper? SuperInstance : SuperClass;
1336 setReceiverPointer(T.getAsOpaquePtr());
1339 Selector getSelector() const;
1341 void setSelector(Selector S) {
1343 SelectorOrMethod = reinterpret_cast<uintptr_t>(S.getAsOpaquePtr());
1346 const ObjCMethodDecl *getMethodDecl() const {
1348 return reinterpret_cast<const ObjCMethodDecl *>(SelectorOrMethod);
1353 ObjCMethodDecl *getMethodDecl() {
1355 return reinterpret_cast<ObjCMethodDecl *>(SelectorOrMethod);
1360 void setMethodDecl(ObjCMethodDecl *MD) {
1362 SelectorOrMethod = reinterpret_cast<uintptr_t>(MD);
1365 ObjCMethodFamily getMethodFamily() const {
1366 if (HasMethod) return getMethodDecl()->getMethodFamily();
1367 return getSelector().getMethodFamily();
1370 /// Return the number of actual arguments in this message,
1371 /// not counting the receiver.
1372 unsigned getNumArgs() const { return NumArgs; }
1374 /// Retrieve the arguments to this message, not including the
1377 return reinterpret_cast<Expr **>(getTrailingObjects<void *>() + 1);
1379 const Expr * const *getArgs() const {
1380 return reinterpret_cast<const Expr *const *>(getTrailingObjects<void *>() +
1384 /// getArg - Return the specified argument.
1385 Expr *getArg(unsigned Arg) {
1386 assert(Arg < NumArgs && "Arg access out of range!");
1387 return getArgs()[Arg];
1389 const Expr *getArg(unsigned Arg) const {
1390 assert(Arg < NumArgs && "Arg access out of range!");
1391 return getArgs()[Arg];
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;
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; }
1406 SourceLocation getLeftLoc() const { return LBracLoc; }
1407 SourceLocation getRightLoc() const { return RBracLoc; }
1409 SourceLocation getSelectorStartLoc() const {
1411 return getBeginLoc();
1412 return getSelectorLoc(0);
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()),
1423 return getStoredSelLocs()[Index];
1426 void getSelectorLocs(SmallVectorImpl<SourceLocation> &SelLocs) const;
1428 unsigned getNumSelectorLocs() const {
1431 Selector Sel = getSelector();
1432 if (Sel.isUnarySelector())
1434 return Sel.getNumArgs();
1437 void setSourceRange(SourceRange R) {
1438 LBracLoc = R.getBegin();
1439 RBracLoc = R.getEnd();
1442 SourceLocation getBeginLoc() const LLVM_READONLY { return LBracLoc; }
1443 SourceLocation getEndLoc() const LLVM_READONLY { return RBracLoc; }
1446 child_range children();
1448 const_child_range children() const;
1450 using arg_iterator = ExprIterator;
1451 using const_arg_iterator = ConstExprIterator;
1453 llvm::iterator_range<arg_iterator> arguments() {
1454 return llvm::make_range(arg_begin(), arg_end());
1457 llvm::iterator_range<const_arg_iterator> arguments() const {
1458 return llvm::make_range(arg_begin(), arg_end());
1461 arg_iterator arg_begin() { return reinterpret_cast<Stmt **>(getArgs()); }
1463 arg_iterator arg_end() {
1464 return reinterpret_cast<Stmt **>(getArgs() + NumArgs);
1467 const_arg_iterator arg_begin() const {
1468 return reinterpret_cast<Stmt const * const*>(getArgs());
1471 const_arg_iterator arg_end() const {
1472 return reinterpret_cast<Stmt const * const*>(getArgs() + NumArgs);
1475 static bool classof(const Stmt *T) {
1476 return T->getStmtClass() == ObjCMessageExprClass;
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.
1486 /// IsaMemberLoc - This is the location of the 'isa'.
1487 SourceLocation IsaMemberLoc;
1489 /// OpLoc - This is the location of '.' or '->'
1490 SourceLocation OpLoc;
1492 /// IsArrow - True if this is "X->F", false if this is "X.F".
1496 ObjCIsaExpr(Expr *base, bool isarrow, SourceLocation l, SourceLocation oploc,
1498 : Expr(ObjCIsaExprClass, ty, VK_LValue, OK_Ordinary), Base(base),
1499 IsaMemberLoc(l), OpLoc(oploc), IsArrow(isarrow) {
1500 setDependence(computeDependence(this));
1503 /// Build an empty expression.
1504 explicit ObjCIsaExpr(EmptyShell Empty) : Expr(ObjCIsaExprClass, Empty) {}
1506 void setBase(Expr *E) { Base = E; }
1507 Expr *getBase() const { return cast<Expr>(Base); }
1509 bool isArrow() const { return IsArrow; }
1510 void setArrow(bool A) { IsArrow = A; }
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; }
1517 SourceLocation getOpLoc() const { return OpLoc; }
1518 void setOpLoc(SourceLocation L) { OpLoc = L; }
1520 SourceLocation getBeginLoc() const LLVM_READONLY {
1521 return getBase()->getBeginLoc();
1524 SourceLocation getBaseLocEnd() const LLVM_READONLY {
1525 return getBase()->getEndLoc();
1528 SourceLocation getEndLoc() const LLVM_READONLY { return IsaMemberLoc; }
1530 SourceLocation getExprLoc() const LLVM_READONLY { return IsaMemberLoc; }
1533 child_range children() { return child_range(&Base, &Base+1); }
1535 const_child_range children() const {
1536 return const_child_range(&Base, &Base + 1);
1539 static bool classof(const Stmt *T) {
1540 return T->getStmtClass() == ObjCIsaExprClass;
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.
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'
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.
1563 /// Currently 'T' must be a retainable object lifetime and must be
1564 /// __autoreleasing; this qualifier is ignored when initializing
1566 class ObjCIndirectCopyRestoreExpr : public Expr {
1567 friend class ASTReader;
1568 friend class ASTStmtReader;
1572 // unsigned ObjCIndirectCopyRestoreBits.ShouldCopy : 1;
1574 explicit ObjCIndirectCopyRestoreExpr(EmptyShell Empty)
1575 : Expr(ObjCIndirectCopyRestoreExprClass, Empty) {}
1577 void setShouldCopy(bool shouldCopy) {
1578 ObjCIndirectCopyRestoreExprBits.ShouldCopy = shouldCopy;
1582 ObjCIndirectCopyRestoreExpr(Expr *operand, QualType type, bool shouldCopy)
1583 : Expr(ObjCIndirectCopyRestoreExprClass, type, VK_LValue, OK_Ordinary),
1585 setShouldCopy(shouldCopy);
1586 setDependence(computeDependence(this));
1589 Expr *getSubExpr() { return cast<Expr>(Operand); }
1590 const Expr *getSubExpr() const { return cast<Expr>(Operand); }
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; }
1596 child_range children() { return child_range(&Operand, &Operand+1); }
1598 const_child_range children() const {
1599 return const_child_range(&Operand, &Operand + 1);
1602 // Source locations are determined by the subexpression.
1603 SourceLocation getBeginLoc() const LLVM_READONLY {
1604 return Operand->getBeginLoc();
1606 SourceLocation getEndLoc() const LLVM_READONLY {
1607 return Operand->getEndLoc();
1610 SourceLocation getExprLoc() const LLVM_READONLY {
1611 return getSubExpr()->getExprLoc();
1614 static bool classof(const Stmt *s) {
1615 return s->getStmtClass() == ObjCIndirectCopyRestoreExprClass;
1619 /// An Objective-C "bridged" cast expression, which casts between
1620 /// Objective-C pointers and C pointers, transferring ownership in the process.
1623 /// NSString *str = (__bridge_transfer NSString *)CFCreateString();
1625 class ObjCBridgedCastExpr final
1626 : public ExplicitCastExpr,
1627 private llvm::TrailingObjects<ObjCBridgedCastExpr, CXXBaseSpecifier *> {
1628 friend class ASTStmtReader;
1629 friend class ASTStmtWriter;
1630 friend class CastExpr;
1631 friend TrailingObjects;
1633 SourceLocation LParenLoc;
1634 SourceLocation BridgeKeywordLoc;
1638 ObjCBridgedCastExpr(SourceLocation LParenLoc, ObjCBridgeCastKind Kind,
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) {}
1645 /// Construct an empty Objective-C bridged cast.
1646 explicit ObjCBridgedCastExpr(EmptyShell Shell)
1647 : ExplicitCastExpr(ObjCBridgedCastExprClass, Shell, 0, false) {}
1649 SourceLocation getLParenLoc() const { return LParenLoc; }
1651 /// Determine which kind of bridge is being performed via this cast.
1652 ObjCBridgeCastKind getBridgeKind() const {
1653 return static_cast<ObjCBridgeCastKind>(Kind);
1656 /// Retrieve the kind of bridge being performed as a string.
1657 StringRef getBridgeKindName() const;
1659 /// The location of the bridge keyword.
1660 SourceLocation getBridgeKeywordLoc() const { return BridgeKeywordLoc; }
1662 SourceLocation getBeginLoc() const LLVM_READONLY { return LParenLoc; }
1664 SourceLocation getEndLoc() const LLVM_READONLY {
1665 return getSubExpr()->getEndLoc();
1668 static bool classof(const Stmt *T) {
1669 return T->getStmtClass() == ObjCBridgedCastExprClass;
1673 /// A runtime availability query.
1675 /// There are 2 ways to spell this node:
1677 /// @available(macos 10.10, ios 8, *); // Objective-C
1678 /// __builtin_available(macos 10.10, ios 8, *); // C, C++, and Objective-C
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
1686 class ObjCAvailabilityCheckExpr : public Expr {
1687 friend class ASTStmtReader;
1689 VersionTuple VersionToCheck;
1690 SourceLocation AtLoc, RParen;
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) {
1697 setDependence(ExprDependence::None);
1700 explicit ObjCAvailabilityCheckExpr(EmptyShell Shell)
1701 : Expr(ObjCAvailabilityCheckExprClass, Shell) {}
1703 SourceLocation getBeginLoc() const { return AtLoc; }
1704 SourceLocation getEndLoc() const { return RParen; }
1705 SourceRange getSourceRange() const { return {AtLoc, RParen}; }
1707 /// This may be '*', in which case this should fold to true.
1708 bool hasVersion() const { return !VersionToCheck.empty(); }
1709 VersionTuple getVersion() const { return VersionToCheck; }
1711 child_range children() {
1712 return child_range(child_iterator(), child_iterator());
1715 const_child_range children() const {
1716 return const_child_range(const_child_iterator(), const_child_iterator());
1719 static bool classof(const Stmt *T) {
1720 return T->getStmtClass() == ObjCAvailabilityCheckExprClass;
1724 } // namespace clang
1726 #endif // LLVM_CLANG_AST_EXPROBJC_H