1 //===--- ExprObjC.h - Classes for representing ObjC expressions -*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the ExprObjC interface and subclasses.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_CLANG_AST_EXPROBJC_H
15 #define LLVM_CLANG_AST_EXPROBJC_H
17 #include "clang/AST/DeclObjC.h"
18 #include "clang/AST/Expr.h"
19 #include "clang/AST/SelectorLocationsKind.h"
20 #include "clang/Basic/IdentifierTable.h"
21 #include "llvm/Support/Compiler.h"
27 /// ObjCStringLiteral, used for Objective-C string literals
29 class ObjCStringLiteral : public Expr {
33 ObjCStringLiteral(StringLiteral *SL, QualType T, SourceLocation L)
34 : Expr(ObjCStringLiteralClass, T, VK_RValue, OK_Ordinary, false, false,
36 String(SL), AtLoc(L) {}
37 explicit ObjCStringLiteral(EmptyShell Empty)
38 : Expr(ObjCStringLiteralClass, Empty) {}
40 StringLiteral *getString() { return cast<StringLiteral>(String); }
41 const StringLiteral *getString() const { return cast<StringLiteral>(String); }
42 void setString(StringLiteral *S) { String = S; }
44 SourceLocation getAtLoc() const { return AtLoc; }
45 void setAtLoc(SourceLocation L) { AtLoc = L; }
47 SourceRange getSourceRange() const LLVM_READONLY {
48 return SourceRange(AtLoc, String->getLocEnd());
51 static bool classof(const Stmt *T) {
52 return T->getStmtClass() == ObjCStringLiteralClass;
54 static bool classof(const ObjCStringLiteral *) { return true; }
57 child_range children() { return child_range(&String, &String+1); }
60 /// ObjCBoolLiteralExpr - Objective-C Boolean Literal.
62 class ObjCBoolLiteralExpr : public Expr {
66 ObjCBoolLiteralExpr(bool val, QualType Ty, SourceLocation l) :
67 Expr(ObjCBoolLiteralExprClass, Ty, VK_RValue, OK_Ordinary, false, false,
68 false, false), Value(val), Loc(l) {}
70 explicit ObjCBoolLiteralExpr(EmptyShell Empty)
71 : Expr(ObjCBoolLiteralExprClass, Empty) { }
73 bool getValue() const { return Value; }
74 void setValue(bool V) { Value = V; }
76 SourceRange getSourceRange() const LLVM_READONLY { return SourceRange(Loc); }
78 SourceLocation getLocation() const { return Loc; }
79 void setLocation(SourceLocation L) { Loc = L; }
81 static bool classof(const Stmt *T) {
82 return T->getStmtClass() == ObjCBoolLiteralExprClass;
84 static bool classof(const ObjCBoolLiteralExpr *) { return true; }
87 child_range children() { return child_range(); }
90 /// ObjCNumericLiteral - used for objective-c numeric literals;
91 /// as in: @42 or @true (c++/objc++) or @__yes (c/objc)
92 class ObjCNumericLiteral : public Expr {
93 /// Number - expression AST node for the numeric literal
95 ObjCMethodDecl *ObjCNumericLiteralMethod;
98 ObjCNumericLiteral(Stmt *NL, QualType T, ObjCMethodDecl *method,
100 : Expr(ObjCNumericLiteralClass, T, VK_RValue, OK_Ordinary,
101 false, false, false, false), Number(NL),
102 ObjCNumericLiteralMethod(method), AtLoc(L) {}
103 explicit ObjCNumericLiteral(EmptyShell Empty)
104 : Expr(ObjCNumericLiteralClass, Empty) {}
106 Expr *getNumber() { return cast<Expr>(Number); }
107 const Expr *getNumber() const { return cast<Expr>(Number); }
109 ObjCMethodDecl *getObjCNumericLiteralMethod() const {
110 return ObjCNumericLiteralMethod;
113 SourceLocation getAtLoc() const { return AtLoc; }
115 SourceRange getSourceRange() const LLVM_READONLY {
116 return SourceRange(AtLoc, Number->getSourceRange().getEnd());
119 static bool classof(const Stmt *T) {
120 return T->getStmtClass() == ObjCNumericLiteralClass;
122 static bool classof(const ObjCNumericLiteral *) { return true; }
125 child_range children() { return child_range(&Number, &Number+1); }
127 friend class ASTStmtReader;
130 /// ObjCArrayLiteral - used for objective-c array containers; as in:
131 /// @[@"Hello", NSApp, [NSNumber numberWithInt:42]];
132 class ObjCArrayLiteral : public Expr {
133 unsigned NumElements;
135 ObjCMethodDecl *ArrayWithObjectsMethod;
137 ObjCArrayLiteral(llvm::ArrayRef<Expr *> Elements,
138 QualType T, ObjCMethodDecl * Method,
141 explicit ObjCArrayLiteral(EmptyShell Empty, unsigned NumElements)
142 : Expr(ObjCArrayLiteralClass, Empty), NumElements(NumElements) {}
145 static ObjCArrayLiteral *Create(ASTContext &C,
146 llvm::ArrayRef<Expr *> Elements,
147 QualType T, ObjCMethodDecl * Method,
150 static ObjCArrayLiteral *CreateEmpty(ASTContext &C, unsigned NumElements);
152 SourceRange getSourceRange() const LLVM_READONLY { return Range; }
154 static bool classof(const Stmt *T) {
155 return T->getStmtClass() == ObjCArrayLiteralClass;
157 static bool classof(const ObjCArrayLiteral *) { return true; }
159 /// \brief Retrieve elements of array of literals.
160 Expr **getElements() { return reinterpret_cast<Expr **>(this + 1); }
162 /// \brief Retrieve elements of array of literals.
163 const Expr * const *getElements() const {
164 return reinterpret_cast<const Expr * const*>(this + 1);
167 /// getNumElements - Return number of elements of objective-c array literal.
168 unsigned getNumElements() const { return NumElements; }
170 /// getExpr - Return the Expr at the specified index.
171 Expr *getElement(unsigned Index) {
172 assert((Index < NumElements) && "Arg access out of range!");
173 return cast<Expr>(getElements()[Index]);
175 const Expr *getElement(unsigned Index) const {
176 assert((Index < NumElements) && "Arg access out of range!");
177 return cast<Expr>(getElements()[Index]);
180 ObjCMethodDecl *getArrayWithObjectsMethod() const {
181 return ArrayWithObjectsMethod;
185 child_range children() {
186 return child_range((Stmt **)getElements(),
187 (Stmt **)getElements() + NumElements);
190 friend class ASTStmtReader;
193 /// \brief An element in an Objective-C dictionary literal.
195 struct ObjCDictionaryElement {
196 /// \brief The key for the dictionary element.
199 /// \brief The value of the dictionary element.
202 /// \brief The location of the ellipsis, if this is a pack expansion.
203 SourceLocation EllipsisLoc;
205 /// \brief The number of elements this pack expansion will expand to, if
206 /// this is a pack expansion and is known.
207 llvm::Optional<unsigned> NumExpansions;
209 /// \brief Determines whether this dictionary element is a pack expansion.
210 bool isPackExpansion() const { return EllipsisLoc.isValid(); }
213 /// ObjCDictionaryLiteral - AST node to represent objective-c dictionary
214 /// literals; as in: @{@"name" : NSUserName(), @"date" : [NSDate date] };
215 class ObjCDictionaryLiteral : public Expr {
216 /// \brief Key/value pair used to store the key and value of a given element.
218 /// Objects of this type are stored directly after the expression.
219 struct KeyValuePair {
224 /// \brief Data that describes an element that is a pack expansion, used if any
225 /// of the elements in the dictionary literal are pack expansions.
226 struct ExpansionData {
227 /// \brief The location of the ellipsis, if this element is a pack
229 SourceLocation EllipsisLoc;
231 /// \brief If non-zero, the number of elements that this pack
232 /// expansion will expand to (+1).
233 unsigned NumExpansionsPlusOne;
236 /// \brief The number of elements in this dictionary literal.
237 unsigned NumElements : 31;
239 /// \brief Determine whether this dictionary literal has any pack expansions.
241 /// If the dictionary literal has pack expansions, then there will
242 /// be an array of pack expansion data following the array of
243 /// key/value pairs, which provide the locations of the ellipses (if
244 /// any) and number of elements in the expansion (if known). If
245 /// there are no pack expansions, we optimize away this storage.
246 unsigned HasPackExpansions : 1;
249 ObjCMethodDecl *DictWithObjectsMethod;
251 ObjCDictionaryLiteral(ArrayRef<ObjCDictionaryElement> VK,
252 bool HasPackExpansions,
253 QualType T, ObjCMethodDecl *method,
256 explicit ObjCDictionaryLiteral(EmptyShell Empty, unsigned NumElements,
257 bool HasPackExpansions)
258 : Expr(ObjCDictionaryLiteralClass, Empty), NumElements(NumElements),
259 HasPackExpansions(HasPackExpansions) {}
261 KeyValuePair *getKeyValues() {
262 return reinterpret_cast<KeyValuePair *>(this + 1);
265 const KeyValuePair *getKeyValues() const {
266 return reinterpret_cast<const KeyValuePair *>(this + 1);
269 ExpansionData *getExpansionData() {
270 if (!HasPackExpansions)
273 return reinterpret_cast<ExpansionData *>(getKeyValues() + NumElements);
276 const ExpansionData *getExpansionData() const {
277 if (!HasPackExpansions)
280 return reinterpret_cast<const ExpansionData *>(getKeyValues()+NumElements);
284 static ObjCDictionaryLiteral *Create(ASTContext &C,
285 ArrayRef<ObjCDictionaryElement> VK,
286 bool HasPackExpansions,
287 QualType T, ObjCMethodDecl *method,
290 static ObjCDictionaryLiteral *CreateEmpty(ASTContext &C,
291 unsigned NumElements,
292 bool HasPackExpansions);
294 /// getNumElements - Return number of elements of objective-c dictionary
296 unsigned getNumElements() const { return NumElements; }
298 ObjCDictionaryElement getKeyValueElement(unsigned Index) const {
299 assert((Index < NumElements) && "Arg access out of range!");
300 const KeyValuePair &KV = getKeyValues()[Index];
301 ObjCDictionaryElement Result = { KV.Key, KV.Value, SourceLocation(),
302 llvm::Optional<unsigned>() };
303 if (HasPackExpansions) {
304 const ExpansionData &Expansion = getExpansionData()[Index];
305 Result.EllipsisLoc = Expansion.EllipsisLoc;
306 if (Expansion.NumExpansionsPlusOne > 0)
307 Result.NumExpansions = Expansion.NumExpansionsPlusOne - 1;
312 ObjCMethodDecl *getDictWithObjectsMethod() const
313 { return DictWithObjectsMethod; }
315 SourceRange getSourceRange() const LLVM_READONLY { return Range; }
317 static bool classof(const Stmt *T) {
318 return T->getStmtClass() == ObjCDictionaryLiteralClass;
320 static bool classof(const ObjCDictionaryLiteral *) { return true; }
323 child_range children() {
324 // Note: we're taking advantage of the layout of the KeyValuePair struct
325 // here. If that struct changes, this code will need to change as well.
326 return child_range(reinterpret_cast<Stmt **>(this + 1),
327 reinterpret_cast<Stmt **>(this + 1) + NumElements * 2);
330 friend class ASTStmtReader;
331 friend class ASTStmtWriter;
335 /// ObjCEncodeExpr, used for @encode in Objective-C. @encode has the same type
336 /// and behavior as StringLiteral except that the string initializer is obtained
337 /// from ASTContext with the encoding type as an argument.
338 class ObjCEncodeExpr : public Expr {
339 TypeSourceInfo *EncodedType;
340 SourceLocation AtLoc, RParenLoc;
342 ObjCEncodeExpr(QualType T, TypeSourceInfo *EncodedType,
343 SourceLocation at, SourceLocation rp)
344 : Expr(ObjCEncodeExprClass, T, VK_LValue, OK_Ordinary,
345 EncodedType->getType()->isDependentType(),
346 EncodedType->getType()->isDependentType(),
347 EncodedType->getType()->isInstantiationDependentType(),
348 EncodedType->getType()->containsUnexpandedParameterPack()),
349 EncodedType(EncodedType), AtLoc(at), RParenLoc(rp) {}
351 explicit ObjCEncodeExpr(EmptyShell Empty) : Expr(ObjCEncodeExprClass, Empty){}
354 SourceLocation getAtLoc() const { return AtLoc; }
355 void setAtLoc(SourceLocation L) { AtLoc = L; }
356 SourceLocation getRParenLoc() const { return RParenLoc; }
357 void setRParenLoc(SourceLocation L) { RParenLoc = L; }
359 QualType getEncodedType() const { return EncodedType->getType(); }
361 TypeSourceInfo *getEncodedTypeSourceInfo() const { return EncodedType; }
362 void setEncodedTypeSourceInfo(TypeSourceInfo *EncType) {
363 EncodedType = EncType;
366 SourceRange getSourceRange() const LLVM_READONLY {
367 return SourceRange(AtLoc, RParenLoc);
370 static bool classof(const Stmt *T) {
371 return T->getStmtClass() == ObjCEncodeExprClass;
373 static bool classof(const ObjCEncodeExpr *) { return true; }
376 child_range children() { return child_range(); }
379 /// ObjCSelectorExpr used for @selector in Objective-C.
380 class ObjCSelectorExpr : public Expr {
382 SourceLocation AtLoc, RParenLoc;
384 ObjCSelectorExpr(QualType T, Selector selInfo,
385 SourceLocation at, SourceLocation rp)
386 : Expr(ObjCSelectorExprClass, T, VK_RValue, OK_Ordinary, false, false,
388 SelName(selInfo), AtLoc(at), RParenLoc(rp){}
389 explicit ObjCSelectorExpr(EmptyShell Empty)
390 : Expr(ObjCSelectorExprClass, Empty) {}
392 Selector getSelector() const { return SelName; }
393 void setSelector(Selector S) { SelName = S; }
395 SourceLocation getAtLoc() const { return AtLoc; }
396 SourceLocation getRParenLoc() const { return RParenLoc; }
397 void setAtLoc(SourceLocation L) { AtLoc = L; }
398 void setRParenLoc(SourceLocation L) { RParenLoc = L; }
400 SourceRange getSourceRange() const LLVM_READONLY {
401 return SourceRange(AtLoc, RParenLoc);
404 /// getNumArgs - Return the number of actual arguments to this call.
405 unsigned getNumArgs() const { return SelName.getNumArgs(); }
407 static bool classof(const Stmt *T) {
408 return T->getStmtClass() == ObjCSelectorExprClass;
410 static bool classof(const ObjCSelectorExpr *) { return true; }
413 child_range children() { return child_range(); }
416 /// ObjCProtocolExpr used for protocol expression in Objective-C. This is used
417 /// as: @protocol(foo), as in:
418 /// obj conformsToProtocol:@protocol(foo)]
419 /// The return type is "Protocol*".
420 class ObjCProtocolExpr : public Expr {
421 ObjCProtocolDecl *TheProtocol;
422 SourceLocation AtLoc, RParenLoc;
424 ObjCProtocolExpr(QualType T, ObjCProtocolDecl *protocol,
425 SourceLocation at, SourceLocation rp)
426 : Expr(ObjCProtocolExprClass, T, VK_RValue, OK_Ordinary, false, false,
428 TheProtocol(protocol), AtLoc(at), RParenLoc(rp) {}
429 explicit ObjCProtocolExpr(EmptyShell Empty)
430 : Expr(ObjCProtocolExprClass, Empty) {}
432 ObjCProtocolDecl *getProtocol() const { return TheProtocol; }
433 void setProtocol(ObjCProtocolDecl *P) { TheProtocol = P; }
435 SourceLocation getAtLoc() const { return AtLoc; }
436 SourceLocation getRParenLoc() const { return RParenLoc; }
437 void setAtLoc(SourceLocation L) { AtLoc = L; }
438 void setRParenLoc(SourceLocation L) { RParenLoc = L; }
440 SourceRange getSourceRange() const LLVM_READONLY {
441 return SourceRange(AtLoc, RParenLoc);
444 static bool classof(const Stmt *T) {
445 return T->getStmtClass() == ObjCProtocolExprClass;
447 static bool classof(const ObjCProtocolExpr *) { return true; }
450 child_range children() { return child_range(); }
453 /// ObjCIvarRefExpr - A reference to an ObjC instance variable.
454 class ObjCIvarRefExpr : public Expr {
458 bool IsArrow:1; // True if this is "X->F", false if this is "X.F".
459 bool IsFreeIvar:1; // True if ivar reference has no base (self assumed).
462 ObjCIvarRefExpr(ObjCIvarDecl *d, QualType t,
463 SourceLocation l, Expr *base,
464 bool arrow = false, bool freeIvar = false) :
465 Expr(ObjCIvarRefExprClass, t, VK_LValue, OK_Ordinary,
466 /*TypeDependent=*/false, base->isValueDependent(),
467 base->isInstantiationDependent(),
468 base->containsUnexpandedParameterPack()),
469 D(d), Base(base), Loc(l), IsArrow(arrow), IsFreeIvar(freeIvar) {}
471 explicit ObjCIvarRefExpr(EmptyShell Empty)
472 : Expr(ObjCIvarRefExprClass, Empty) {}
474 ObjCIvarDecl *getDecl() { return D; }
475 const ObjCIvarDecl *getDecl() const { return D; }
476 void setDecl(ObjCIvarDecl *d) { D = d; }
478 const Expr *getBase() const { return cast<Expr>(Base); }
479 Expr *getBase() { return cast<Expr>(Base); }
480 void setBase(Expr * base) { Base = base; }
482 bool isArrow() const { return IsArrow; }
483 bool isFreeIvar() const { return IsFreeIvar; }
484 void setIsArrow(bool A) { IsArrow = A; }
485 void setIsFreeIvar(bool A) { IsFreeIvar = A; }
487 SourceLocation getLocation() const { return Loc; }
488 void setLocation(SourceLocation L) { Loc = L; }
490 SourceRange getSourceRange() const LLVM_READONLY {
491 return isFreeIvar() ? SourceRange(Loc)
492 : SourceRange(getBase()->getLocStart(), Loc);
495 static bool classof(const Stmt *T) {
496 return T->getStmtClass() == ObjCIvarRefExprClass;
498 static bool classof(const ObjCIvarRefExpr *) { return true; }
501 child_range children() { return child_range(&Base, &Base+1); }
504 /// ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC
506 class ObjCPropertyRefExpr : public Expr {
508 /// If the bool is true, this is an implicit property reference; the
509 /// pointer is an (optional) ObjCMethodDecl and Setter may be set.
510 /// if the bool is false, this is an explicit property reference;
511 /// the pointer is an ObjCPropertyDecl and Setter is always null.
512 llvm::PointerIntPair<NamedDecl*, 1, bool> PropertyOrGetter;
514 /// \brief Indicates whether the property reference will result in a message
515 /// to the getter, the setter, or both.
516 /// This applies to both implicit and explicit property references.
517 enum MethodRefFlags {
519 MethodRef_Getter = 0x1,
520 MethodRef_Setter = 0x2
523 /// \brief Contains the Setter method pointer and MethodRefFlags bit flags.
524 llvm::PointerIntPair<ObjCMethodDecl *, 2, unsigned> SetterAndMethodRefFlags;
526 // FIXME: Maybe we should store the property identifier here,
527 // because it's not rederivable from the other data when there's an
528 // implicit property with no getter (because the 'foo' -> 'setFoo:'
529 // transformation is lossy on the first character).
531 SourceLocation IdLoc;
533 /// \brief When the receiver in property access is 'super', this is
534 /// the location of the 'super' keyword. When it's an interface,
535 /// this is that interface.
536 SourceLocation ReceiverLoc;
537 llvm::PointerUnion3<Stmt*, const Type*, ObjCInterfaceDecl*> Receiver;
540 ObjCPropertyRefExpr(ObjCPropertyDecl *PD, QualType t,
541 ExprValueKind VK, ExprObjectKind OK,
542 SourceLocation l, Expr *base)
543 : Expr(ObjCPropertyRefExprClass, t, VK, OK,
544 /*TypeDependent=*/false, base->isValueDependent(),
545 base->isInstantiationDependent(),
546 base->containsUnexpandedParameterPack()),
547 PropertyOrGetter(PD, false), SetterAndMethodRefFlags(),
548 IdLoc(l), ReceiverLoc(), Receiver(base) {
549 assert(t->isSpecificPlaceholderType(BuiltinType::PseudoObject));
552 ObjCPropertyRefExpr(ObjCPropertyDecl *PD, QualType t,
553 ExprValueKind VK, ExprObjectKind OK,
554 SourceLocation l, SourceLocation sl, QualType st)
555 : Expr(ObjCPropertyRefExprClass, t, VK, OK,
556 /*TypeDependent=*/false, false, st->isInstantiationDependentType(),
557 st->containsUnexpandedParameterPack()),
558 PropertyOrGetter(PD, false), SetterAndMethodRefFlags(),
559 IdLoc(l), ReceiverLoc(sl), Receiver(st.getTypePtr()) {
560 assert(t->isSpecificPlaceholderType(BuiltinType::PseudoObject));
563 ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter,
564 QualType T, ExprValueKind VK, ExprObjectKind OK,
565 SourceLocation IdLoc, Expr *Base)
566 : Expr(ObjCPropertyRefExprClass, T, VK, OK, false,
567 Base->isValueDependent(), Base->isInstantiationDependent(),
568 Base->containsUnexpandedParameterPack()),
569 PropertyOrGetter(Getter, true), SetterAndMethodRefFlags(Setter, 0),
570 IdLoc(IdLoc), ReceiverLoc(), Receiver(Base) {
571 assert(T->isSpecificPlaceholderType(BuiltinType::PseudoObject));
574 ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter,
575 QualType T, ExprValueKind VK, ExprObjectKind OK,
576 SourceLocation IdLoc,
577 SourceLocation SuperLoc, QualType SuperTy)
578 : Expr(ObjCPropertyRefExprClass, T, VK, OK, false, false, false, false),
579 PropertyOrGetter(Getter, true), SetterAndMethodRefFlags(Setter, 0),
580 IdLoc(IdLoc), ReceiverLoc(SuperLoc), Receiver(SuperTy.getTypePtr()) {
581 assert(T->isSpecificPlaceholderType(BuiltinType::PseudoObject));
584 ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter,
585 QualType T, ExprValueKind VK, ExprObjectKind OK,
586 SourceLocation IdLoc,
587 SourceLocation ReceiverLoc, ObjCInterfaceDecl *Receiver)
588 : Expr(ObjCPropertyRefExprClass, T, VK, OK, false, false, false, false),
589 PropertyOrGetter(Getter, true), SetterAndMethodRefFlags(Setter, 0),
590 IdLoc(IdLoc), ReceiverLoc(ReceiverLoc), Receiver(Receiver) {
591 assert(T->isSpecificPlaceholderType(BuiltinType::PseudoObject));
594 explicit ObjCPropertyRefExpr(EmptyShell Empty)
595 : Expr(ObjCPropertyRefExprClass, Empty) {}
597 bool isImplicitProperty() const { return PropertyOrGetter.getInt(); }
598 bool isExplicitProperty() const { return !PropertyOrGetter.getInt(); }
600 ObjCPropertyDecl *getExplicitProperty() const {
601 assert(!isImplicitProperty());
602 return cast<ObjCPropertyDecl>(PropertyOrGetter.getPointer());
605 ObjCMethodDecl *getImplicitPropertyGetter() const {
606 assert(isImplicitProperty());
607 return cast_or_null<ObjCMethodDecl>(PropertyOrGetter.getPointer());
610 ObjCMethodDecl *getImplicitPropertySetter() const {
611 assert(isImplicitProperty());
612 return SetterAndMethodRefFlags.getPointer();
615 Selector getGetterSelector() const {
616 if (isImplicitProperty())
617 return getImplicitPropertyGetter()->getSelector();
618 return getExplicitProperty()->getGetterName();
621 Selector getSetterSelector() const {
622 if (isImplicitProperty())
623 return getImplicitPropertySetter()->getSelector();
624 return getExplicitProperty()->getSetterName();
627 /// \brief True if the property reference will result in a message to the
629 /// This applies to both implicit and explicit property references.
630 bool isMessagingGetter() const {
631 return SetterAndMethodRefFlags.getInt() & MethodRef_Getter;
634 /// \brief True if the property reference will result in a message to the
636 /// This applies to both implicit and explicit property references.
637 bool isMessagingSetter() const {
638 return SetterAndMethodRefFlags.getInt() & MethodRef_Setter;
641 void setIsMessagingGetter(bool val = true) {
642 setMethodRefFlag(MethodRef_Getter, val);
645 void setIsMessagingSetter(bool val = true) {
646 setMethodRefFlag(MethodRef_Setter, val);
649 const Expr *getBase() const {
650 return cast<Expr>(Receiver.get<Stmt*>());
653 return cast<Expr>(Receiver.get<Stmt*>());
656 SourceLocation getLocation() const { return IdLoc; }
658 SourceLocation getReceiverLocation() const { return ReceiverLoc; }
659 QualType getSuperReceiverType() const {
660 return QualType(Receiver.get<const Type*>(), 0);
662 QualType getGetterResultType() const {
664 if (isExplicitProperty()) {
665 const ObjCPropertyDecl *PDecl = getExplicitProperty();
666 if (const ObjCMethodDecl *Getter = PDecl->getGetterMethodDecl())
667 ResultType = Getter->getResultType();
669 ResultType = PDecl->getType();
671 const ObjCMethodDecl *Getter = getImplicitPropertyGetter();
673 ResultType = Getter->getResultType(); // with reference!
678 QualType getSetterArgType() const {
680 if (isImplicitProperty()) {
681 const ObjCMethodDecl *Setter = getImplicitPropertySetter();
682 ObjCMethodDecl::param_const_iterator P = Setter->param_begin();
683 ArgType = (*P)->getType();
685 if (ObjCPropertyDecl *PDecl = getExplicitProperty())
686 if (const ObjCMethodDecl *Setter = PDecl->getSetterMethodDecl()) {
687 ObjCMethodDecl::param_const_iterator P = Setter->param_begin();
688 ArgType = (*P)->getType();
690 if (ArgType.isNull())
696 ObjCInterfaceDecl *getClassReceiver() const {
697 return Receiver.get<ObjCInterfaceDecl*>();
699 bool isObjectReceiver() const { return Receiver.is<Stmt*>(); }
700 bool isSuperReceiver() const { return Receiver.is<const Type*>(); }
701 bool isClassReceiver() const { return Receiver.is<ObjCInterfaceDecl*>(); }
703 SourceRange getSourceRange() const LLVM_READONLY {
704 return SourceRange((isObjectReceiver() ? getBase()->getLocStart()
705 : getReceiverLocation()),
709 static bool classof(const Stmt *T) {
710 return T->getStmtClass() == ObjCPropertyRefExprClass;
712 static bool classof(const ObjCPropertyRefExpr *) { return true; }
715 child_range children() {
716 if (Receiver.is<Stmt*>()) {
717 Stmt **begin = reinterpret_cast<Stmt**>(&Receiver); // hack!
718 return child_range(begin, begin+1);
720 return child_range();
724 friend class ASTStmtReader;
725 friend class ASTStmtWriter;
726 void setExplicitProperty(ObjCPropertyDecl *D, unsigned methRefFlags) {
727 PropertyOrGetter.setPointer(D);
728 PropertyOrGetter.setInt(false);
729 SetterAndMethodRefFlags.setPointer(0);
730 SetterAndMethodRefFlags.setInt(methRefFlags);
732 void setImplicitProperty(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter,
733 unsigned methRefFlags) {
734 PropertyOrGetter.setPointer(Getter);
735 PropertyOrGetter.setInt(true);
736 SetterAndMethodRefFlags.setPointer(Setter);
737 SetterAndMethodRefFlags.setInt(methRefFlags);
739 void setBase(Expr *Base) { Receiver = Base; }
740 void setSuperReceiver(QualType T) { Receiver = T.getTypePtr(); }
741 void setClassReceiver(ObjCInterfaceDecl *D) { Receiver = D; }
743 void setLocation(SourceLocation L) { IdLoc = L; }
744 void setReceiverLocation(SourceLocation Loc) { ReceiverLoc = Loc; }
746 void setMethodRefFlag(MethodRefFlags flag, bool val) {
747 unsigned f = SetterAndMethodRefFlags.getInt();
752 SetterAndMethodRefFlags.setInt(f);
756 /// ObjCSubscriptRefExpr - used for array and dictionary subscripting.
757 /// array[4] = array[3]; dictionary[key] = dictionary[alt_key];
759 class ObjCSubscriptRefExpr : public Expr {
760 // Location of ']' in an indexing expression.
761 SourceLocation RBracket;
762 // array/dictionary base expression.
763 // for arrays, this is a numeric expression. For dictionaries, this is
764 // an objective-c object pointer expression.
765 enum { BASE, KEY, END_EXPR };
766 Stmt* SubExprs[END_EXPR];
768 ObjCMethodDecl *GetAtIndexMethodDecl;
770 // For immutable objects this is null. When ObjCSubscriptRefExpr is to read
771 // an indexed object this is null too.
772 ObjCMethodDecl *SetAtIndexMethodDecl;
776 ObjCSubscriptRefExpr(Expr *base, Expr *key, QualType T,
777 ExprValueKind VK, ExprObjectKind OK,
778 ObjCMethodDecl *getMethod,
779 ObjCMethodDecl *setMethod, SourceLocation RB)
780 : Expr(ObjCSubscriptRefExprClass, T, VK, OK,
781 base->isTypeDependent() || key->isTypeDependent(),
782 base->isValueDependent() || key->isValueDependent(),
783 base->isInstantiationDependent() || key->isInstantiationDependent(),
784 (base->containsUnexpandedParameterPack() ||
785 key->containsUnexpandedParameterPack())),
787 GetAtIndexMethodDecl(getMethod),
788 SetAtIndexMethodDecl(setMethod)
789 {SubExprs[BASE] = base; SubExprs[KEY] = key;}
791 explicit ObjCSubscriptRefExpr(EmptyShell Empty)
792 : Expr(ObjCSubscriptRefExprClass, Empty) {}
794 static ObjCSubscriptRefExpr *Create(ASTContext &C,
796 Expr *key, QualType T,
797 ObjCMethodDecl *getMethod,
798 ObjCMethodDecl *setMethod,
801 SourceLocation getRBracket() const { return RBracket; }
802 void setRBracket(SourceLocation RB) { RBracket = RB; }
803 SourceRange getSourceRange() const LLVM_READONLY {
804 return SourceRange(SubExprs[BASE]->getLocStart(), RBracket);
807 static bool classof(const Stmt *T) {
808 return T->getStmtClass() == ObjCSubscriptRefExprClass;
810 static bool classof(const ObjCSubscriptRefExpr *) { return true; }
812 Expr *getBaseExpr() const { return cast<Expr>(SubExprs[BASE]); }
813 void setBaseExpr(Stmt *S) { SubExprs[BASE] = S; }
815 Expr *getKeyExpr() const { return cast<Expr>(SubExprs[KEY]); }
816 void setKeyExpr(Stmt *S) { SubExprs[KEY] = S; }
818 ObjCMethodDecl *getAtIndexMethodDecl() const {
819 return GetAtIndexMethodDecl;
822 ObjCMethodDecl *setAtIndexMethodDecl() const {
823 return SetAtIndexMethodDecl;
826 bool isArraySubscriptRefExpr() const {
827 return getKeyExpr()->getType()->isIntegralOrEnumerationType();
830 child_range children() {
831 return child_range(SubExprs, SubExprs+END_EXPR);
834 friend class ASTStmtReader;
838 /// \brief An expression that sends a message to the given Objective-C
841 /// The following contains two message send expressions:
844 /// [[NSString alloc] initWithString:@"Hello"]
847 /// The innermost message send invokes the "alloc" class method on the
848 /// NSString class, while the outermost message send invokes the
849 /// "initWithString" instance method on the object returned from
850 /// NSString's "alloc". In all, an Objective-C message send can take
851 /// on four different (although related) forms:
853 /// 1. Send to an object instance.
854 /// 2. Send to a class.
855 /// 3. Send to the superclass instance of the current class.
856 /// 4. Send to the superclass of the current class.
858 /// All four kinds of message sends are modeled by the ObjCMessageExpr
859 /// class, and can be distinguished via \c getReceiverKind(). Example:
861 class ObjCMessageExpr : public Expr {
862 /// \brief Stores either the selector that this message is sending
863 /// to (when \c HasMethod is zero) or an \c ObjCMethodDecl pointer
864 /// referring to the method that we type-checked against.
865 uintptr_t SelectorOrMethod;
867 enum { NumArgsBitWidth = 16 };
869 /// \brief The number of arguments in the message send, not
870 /// including the receiver.
871 unsigned NumArgs : NumArgsBitWidth;
873 void setNumArgs(unsigned Num) {
874 assert((Num >> NumArgsBitWidth) == 0 && "Num of args is out of range!");
878 /// \brief The kind of message send this is, which is one of the
879 /// ReceiverKind values.
881 /// We pad this out to a byte to avoid excessive masking and shifting.
884 /// \brief Whether we have an actual method prototype in \c
885 /// SelectorOrMethod.
887 /// When non-zero, we have a method declaration; otherwise, we just
889 unsigned HasMethod : 1;
891 /// \brief Whether this message send is a "delegate init call",
892 /// i.e. a call of an init method on self from within an init method.
893 unsigned IsDelegateInitCall : 1;
895 /// \brief Whether this message send was implicitly generated by
896 /// the implementation rather than explicitly written by the user.
897 unsigned IsImplicit : 1;
899 /// \brief Whether the locations of the selector identifiers are in a
900 /// "standard" position, a enum SelectorLocationsKind.
901 unsigned SelLocsKind : 2;
903 /// \brief When the message expression is a send to 'super', this is
904 /// the location of the 'super' keyword.
905 SourceLocation SuperLoc;
907 /// \brief The source locations of the open and close square
908 /// brackets ('[' and ']', respectively).
909 SourceLocation LBracLoc, RBracLoc;
911 ObjCMessageExpr(EmptyShell Empty, unsigned NumArgs)
912 : Expr(ObjCMessageExprClass, Empty), SelectorOrMethod(0), Kind(0),
913 HasMethod(0), IsDelegateInitCall(0), IsImplicit(0), SelLocsKind(0) {
917 ObjCMessageExpr(QualType T, ExprValueKind VK,
918 SourceLocation LBracLoc,
919 SourceLocation SuperLoc,
920 bool IsInstanceSuper,
923 ArrayRef<SourceLocation> SelLocs,
924 SelectorLocationsKind SelLocsK,
925 ObjCMethodDecl *Method,
926 ArrayRef<Expr *> Args,
927 SourceLocation RBracLoc,
929 ObjCMessageExpr(QualType T, ExprValueKind VK,
930 SourceLocation LBracLoc,
931 TypeSourceInfo *Receiver,
933 ArrayRef<SourceLocation> SelLocs,
934 SelectorLocationsKind SelLocsK,
935 ObjCMethodDecl *Method,
936 ArrayRef<Expr *> Args,
937 SourceLocation RBracLoc,
939 ObjCMessageExpr(QualType T, ExprValueKind VK,
940 SourceLocation LBracLoc,
943 ArrayRef<SourceLocation> SelLocs,
944 SelectorLocationsKind SelLocsK,
945 ObjCMethodDecl *Method,
946 ArrayRef<Expr *> Args,
947 SourceLocation RBracLoc,
950 void initArgsAndSelLocs(ArrayRef<Expr *> Args,
951 ArrayRef<SourceLocation> SelLocs,
952 SelectorLocationsKind SelLocsK);
954 /// \brief Retrieve the pointer value of the message receiver.
955 void *getReceiverPointer() const {
956 return *const_cast<void **>(
957 reinterpret_cast<const void * const*>(this + 1));
960 /// \brief Set the pointer value of the message receiver.
961 void setReceiverPointer(void *Value) {
962 *reinterpret_cast<void **>(this + 1) = Value;
965 SelectorLocationsKind getSelLocsKind() const {
966 return (SelectorLocationsKind)SelLocsKind;
968 bool hasStandardSelLocs() const {
969 return getSelLocsKind() != SelLoc_NonStandard;
972 /// \brief Get a pointer to the stored selector identifiers locations array.
973 /// No locations will be stored if HasStandardSelLocs is true.
974 SourceLocation *getStoredSelLocs() {
975 return reinterpret_cast<SourceLocation*>(getArgs() + getNumArgs());
977 const SourceLocation *getStoredSelLocs() const {
978 return reinterpret_cast<const SourceLocation*>(getArgs() + getNumArgs());
981 /// \brief Get the number of stored selector identifiers locations.
982 /// No locations will be stored if HasStandardSelLocs is true.
983 unsigned getNumStoredSelLocs() const {
984 if (hasStandardSelLocs())
986 return getNumSelectorLocs();
989 static ObjCMessageExpr *alloc(ASTContext &C,
990 ArrayRef<Expr *> Args,
991 SourceLocation RBraceLoc,
992 ArrayRef<SourceLocation> SelLocs,
994 SelectorLocationsKind &SelLocsK);
995 static ObjCMessageExpr *alloc(ASTContext &C,
997 unsigned NumStoredSelLocs);
1000 /// \brief The kind of receiver this message is sending to.
1002 /// \brief The receiver is a class.
1004 /// \brief The receiver is an object instance.
1006 /// \brief The receiver is a superclass.
1008 /// \brief The receiver is the instance of the superclass object.
1012 /// \brief Create a message send to super.
1014 /// \param Context The ASTContext in which this expression will be created.
1016 /// \param T The result type of this message.
1018 /// \param VK The value kind of this message. A message returning
1019 /// a l-value or r-value reference will be an l-value or x-value,
1022 /// \param LBrac The location of the open square bracket '['.
1024 /// \param SuperLoc The location of the "super" keyword.
1026 /// \param IsInstanceSuper Whether this is an instance "super"
1027 /// message (otherwise, it's a class "super" message).
1029 /// \param Sel The selector used to determine which method gets called.
1031 /// \param Method The Objective-C method against which this message
1032 /// send was type-checked. May be NULL.
1034 /// \param Args The message send arguments.
1036 /// \param NumArgs The number of arguments.
1038 /// \param RBracLoc The location of the closing square bracket ']'.
1039 static ObjCMessageExpr *Create(ASTContext &Context, QualType T,
1041 SourceLocation LBracLoc,
1042 SourceLocation SuperLoc,
1043 bool IsInstanceSuper,
1046 ArrayRef<SourceLocation> SelLocs,
1047 ObjCMethodDecl *Method,
1048 ArrayRef<Expr *> Args,
1049 SourceLocation RBracLoc,
1052 /// \brief Create a class message send.
1054 /// \param Context The ASTContext in which this expression will be created.
1056 /// \param T The result type of this message.
1058 /// \param VK The value kind of this message. A message returning
1059 /// a l-value or r-value reference will be an l-value or x-value,
1062 /// \param LBrac The location of the open square bracket '['.
1064 /// \param Receiver The type of the receiver, including
1065 /// source-location information.
1067 /// \param Sel The selector used to determine which method gets called.
1069 /// \param Method The Objective-C method against which this message
1070 /// send was type-checked. May be NULL.
1072 /// \param Args The message send arguments.
1074 /// \param NumArgs The number of arguments.
1076 /// \param RBracLoc The location of the closing square bracket ']'.
1077 static ObjCMessageExpr *Create(ASTContext &Context, QualType T,
1079 SourceLocation LBracLoc,
1080 TypeSourceInfo *Receiver,
1082 ArrayRef<SourceLocation> SelLocs,
1083 ObjCMethodDecl *Method,
1084 ArrayRef<Expr *> Args,
1085 SourceLocation RBracLoc,
1088 /// \brief Create an instance message send.
1090 /// \param Context The ASTContext in which this expression will be created.
1092 /// \param T The result type of this message.
1094 /// \param VK The value kind of this message. A message returning
1095 /// a l-value or r-value reference will be an l-value or x-value,
1098 /// \param LBrac The location of the open square bracket '['.
1100 /// \param Receiver The expression used to produce the object that
1101 /// will receive this message.
1103 /// \param Sel The selector used to determine which method gets called.
1105 /// \param Method The Objective-C method against which this message
1106 /// send was type-checked. May be NULL.
1108 /// \param Args The message send arguments.
1110 /// \param NumArgs The number of arguments.
1112 /// \param RBracLoc The location of the closing square bracket ']'.
1113 static ObjCMessageExpr *Create(ASTContext &Context, QualType T,
1115 SourceLocation LBracLoc,
1118 ArrayRef<SourceLocation> SeLocs,
1119 ObjCMethodDecl *Method,
1120 ArrayRef<Expr *> Args,
1121 SourceLocation RBracLoc,
1124 /// \brief Create an empty Objective-C message expression, to be
1125 /// filled in by subsequent calls.
1127 /// \param Context The context in which the message send will be created.
1129 /// \param NumArgs The number of message arguments, not including
1131 static ObjCMessageExpr *CreateEmpty(ASTContext &Context,
1133 unsigned NumStoredSelLocs);
1135 /// \brief Indicates whether the message send was implicitly
1136 /// generated by the implementation. If false, it was written explicitly
1137 /// in the source code.
1138 bool isImplicit() const { return IsImplicit; }
1140 /// \brief Determine the kind of receiver that this message is being
1142 ReceiverKind getReceiverKind() const { return (ReceiverKind)Kind; }
1144 /// \brief Source range of the receiver.
1145 SourceRange getReceiverRange() const;
1147 /// \brief Determine whether this is an instance message to either a
1148 /// computed object or to super.
1149 bool isInstanceMessage() const {
1150 return getReceiverKind() == Instance || getReceiverKind() == SuperInstance;
1153 /// \brief Determine whether this is an class message to either a
1154 /// specified class or to super.
1155 bool isClassMessage() const {
1156 return getReceiverKind() == Class || getReceiverKind() == SuperClass;
1159 /// \brief Returns the receiver of an instance message.
1161 /// \brief Returns the object expression for an instance message, or
1162 /// NULL for a message that is not an instance message.
1163 Expr *getInstanceReceiver() {
1164 if (getReceiverKind() == Instance)
1165 return static_cast<Expr *>(getReceiverPointer());
1169 const Expr *getInstanceReceiver() const {
1170 return const_cast<ObjCMessageExpr*>(this)->getInstanceReceiver();
1173 /// \brief Turn this message send into an instance message that
1174 /// computes the receiver object with the given expression.
1175 void setInstanceReceiver(Expr *rec) {
1177 setReceiverPointer(rec);
1180 /// \brief Returns the type of a class message send, or NULL if the
1181 /// message is not a class message.
1182 QualType getClassReceiver() const {
1183 if (TypeSourceInfo *TSInfo = getClassReceiverTypeInfo())
1184 return TSInfo->getType();
1189 /// \brief Returns a type-source information of a class message
1190 /// send, or NULL if the message is not a class message.
1191 TypeSourceInfo *getClassReceiverTypeInfo() const {
1192 if (getReceiverKind() == Class)
1193 return reinterpret_cast<TypeSourceInfo *>(getReceiverPointer());
1197 void setClassReceiver(TypeSourceInfo *TSInfo) {
1199 setReceiverPointer(TSInfo);
1202 /// \brief Retrieve the location of the 'super' keyword for a class
1203 /// or instance message to 'super', otherwise an invalid source location.
1204 SourceLocation getSuperLoc() const {
1205 if (getReceiverKind() == SuperInstance || getReceiverKind() == SuperClass)
1208 return SourceLocation();
1211 /// \brief Retrieve the Objective-C interface to which this message
1212 /// is being directed, if known.
1214 /// This routine cross-cuts all of the different kinds of message
1215 /// sends to determine what the underlying (statically known) type
1216 /// of the receiver will be; use \c getReceiverKind() to determine
1217 /// whether the message is a class or an instance method, whether it
1218 /// is a send to super or not, etc.
1220 /// \returns The Objective-C interface if known, otherwise NULL.
1221 ObjCInterfaceDecl *getReceiverInterface() const;
1223 /// \brief Retrieve the type referred to by 'super'.
1225 /// The returned type will either be an ObjCInterfaceType (for an
1226 /// class message to super) or an ObjCObjectPointerType that refers
1227 /// to a class (for an instance message to super);
1228 QualType getSuperType() const {
1229 if (getReceiverKind() == SuperInstance || getReceiverKind() == SuperClass)
1230 return QualType::getFromOpaquePtr(getReceiverPointer());
1235 void setSuper(SourceLocation Loc, QualType T, bool IsInstanceSuper) {
1236 Kind = IsInstanceSuper? SuperInstance : SuperClass;
1238 setReceiverPointer(T.getAsOpaquePtr());
1241 Selector getSelector() const;
1243 void setSelector(Selector S) {
1245 SelectorOrMethod = reinterpret_cast<uintptr_t>(S.getAsOpaquePtr());
1248 const ObjCMethodDecl *getMethodDecl() const {
1250 return reinterpret_cast<const ObjCMethodDecl *>(SelectorOrMethod);
1255 ObjCMethodDecl *getMethodDecl() {
1257 return reinterpret_cast<ObjCMethodDecl *>(SelectorOrMethod);
1262 void setMethodDecl(ObjCMethodDecl *MD) {
1264 SelectorOrMethod = reinterpret_cast<uintptr_t>(MD);
1267 ObjCMethodFamily getMethodFamily() const {
1268 if (HasMethod) return getMethodDecl()->getMethodFamily();
1269 return getSelector().getMethodFamily();
1272 /// \brief Return the number of actual arguments in this message,
1273 /// not counting the receiver.
1274 unsigned getNumArgs() const { return NumArgs; }
1276 /// \brief Retrieve the arguments to this message, not including the
1279 return reinterpret_cast<Expr **>(this + 1) + 1;
1281 const Expr * const *getArgs() const {
1282 return reinterpret_cast<const Expr * const *>(this + 1) + 1;
1285 /// getArg - Return the specified argument.
1286 Expr *getArg(unsigned Arg) {
1287 assert(Arg < NumArgs && "Arg access out of range!");
1288 return cast<Expr>(getArgs()[Arg]);
1290 const Expr *getArg(unsigned Arg) const {
1291 assert(Arg < NumArgs && "Arg access out of range!");
1292 return cast<Expr>(getArgs()[Arg]);
1294 /// setArg - Set the specified argument.
1295 void setArg(unsigned Arg, Expr *ArgExpr) {
1296 assert(Arg < NumArgs && "Arg access out of range!");
1297 getArgs()[Arg] = ArgExpr;
1300 /// isDelegateInitCall - Answers whether this message send has been
1301 /// tagged as a "delegate init call", i.e. a call to a method in the
1302 /// -init family on self from within an -init method implementation.
1303 bool isDelegateInitCall() const { return IsDelegateInitCall; }
1304 void setDelegateInitCall(bool isDelegate) { IsDelegateInitCall = isDelegate; }
1306 SourceLocation getLeftLoc() const { return LBracLoc; }
1307 SourceLocation getRightLoc() const { return RBracLoc; }
1309 SourceLocation getSelectorStartLoc() const {
1311 return getLocStart();
1312 return getSelectorLoc(0);
1314 SourceLocation getSelectorLoc(unsigned Index) const {
1315 assert(Index < getNumSelectorLocs() && "Index out of range!");
1316 if (hasStandardSelLocs())
1317 return getStandardSelectorLoc(Index, getSelector(),
1318 getSelLocsKind() == SelLoc_StandardWithSpace,
1319 llvm::makeArrayRef(const_cast<Expr**>(getArgs()),
1322 return getStoredSelLocs()[Index];
1325 void getSelectorLocs(SmallVectorImpl<SourceLocation> &SelLocs) const;
1327 unsigned getNumSelectorLocs() const {
1330 Selector Sel = getSelector();
1331 if (Sel.isUnarySelector())
1333 return Sel.getNumArgs();
1336 void setSourceRange(SourceRange R) {
1337 LBracLoc = R.getBegin();
1338 RBracLoc = R.getEnd();
1340 SourceRange getSourceRange() const LLVM_READONLY {
1341 return SourceRange(LBracLoc, RBracLoc);
1344 static bool classof(const Stmt *T) {
1345 return T->getStmtClass() == ObjCMessageExprClass;
1347 static bool classof(const ObjCMessageExpr *) { return true; }
1350 child_range children();
1352 typedef ExprIterator arg_iterator;
1353 typedef ConstExprIterator const_arg_iterator;
1355 arg_iterator arg_begin() { return reinterpret_cast<Stmt **>(getArgs()); }
1356 arg_iterator arg_end() {
1357 return reinterpret_cast<Stmt **>(getArgs() + NumArgs);
1359 const_arg_iterator arg_begin() const {
1360 return reinterpret_cast<Stmt const * const*>(getArgs());
1362 const_arg_iterator arg_end() const {
1363 return reinterpret_cast<Stmt const * const*>(getArgs() + NumArgs);
1366 friend class ASTStmtReader;
1367 friend class ASTStmtWriter;
1370 /// ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
1371 /// (similar in spirit to MemberExpr).
1372 class ObjCIsaExpr : public Expr {
1373 /// Base - the expression for the base object pointer.
1376 /// IsaMemberLoc - This is the location of the 'isa'.
1377 SourceLocation IsaMemberLoc;
1379 /// IsArrow - True if this is "X->F", false if this is "X.F".
1382 ObjCIsaExpr(Expr *base, bool isarrow, SourceLocation l, QualType ty)
1383 : Expr(ObjCIsaExprClass, ty, VK_LValue, OK_Ordinary,
1384 /*TypeDependent=*/false, base->isValueDependent(),
1385 base->isInstantiationDependent(),
1386 /*ContainsUnexpandedParameterPack=*/false),
1387 Base(base), IsaMemberLoc(l), IsArrow(isarrow) {}
1389 /// \brief Build an empty expression.
1390 explicit ObjCIsaExpr(EmptyShell Empty) : Expr(ObjCIsaExprClass, Empty) { }
1392 void setBase(Expr *E) { Base = E; }
1393 Expr *getBase() const { return cast<Expr>(Base); }
1395 bool isArrow() const { return IsArrow; }
1396 void setArrow(bool A) { IsArrow = A; }
1398 /// getMemberLoc - Return the location of the "member", in X->F, it is the
1399 /// location of 'F'.
1400 SourceLocation getIsaMemberLoc() const { return IsaMemberLoc; }
1401 void setIsaMemberLoc(SourceLocation L) { IsaMemberLoc = L; }
1403 SourceRange getSourceRange() const LLVM_READONLY {
1404 return SourceRange(getBase()->getLocStart(), IsaMemberLoc);
1407 SourceLocation getExprLoc() const LLVM_READONLY { return IsaMemberLoc; }
1409 static bool classof(const Stmt *T) {
1410 return T->getStmtClass() == ObjCIsaExprClass;
1412 static bool classof(const ObjCIsaExpr *) { return true; }
1415 child_range children() { return child_range(&Base, &Base+1); }
1419 /// ObjCIndirectCopyRestoreExpr - Represents the passing of a function
1420 /// argument by indirect copy-restore in ARC. This is used to support
1421 /// passing indirect arguments with the wrong lifetime, e.g. when
1422 /// passing the address of a __strong local variable to an 'out'
1423 /// parameter. This expression kind is only valid in an "argument"
1424 /// position to some sort of call expression.
1426 /// The parameter must have type 'pointer to T', and the argument must
1427 /// have type 'pointer to U', where T and U agree except possibly in
1428 /// qualification. If the argument value is null, then a null pointer
1429 /// is passed; otherwise it points to an object A, and:
1430 /// 1. A temporary object B of type T is initialized, either by
1431 /// zero-initialization (used when initializing an 'out' parameter)
1432 /// or copy-initialization (used when initializing an 'inout'
1434 /// 2. The address of the temporary is passed to the function.
1435 /// 3. If the call completes normally, A is move-assigned from B.
1436 /// 4. Finally, A is destroyed immediately.
1438 /// Currently 'T' must be a retainable object lifetime and must be
1439 /// __autoreleasing; this qualifier is ignored when initializing
1441 class ObjCIndirectCopyRestoreExpr : public Expr {
1444 // unsigned ObjCIndirectCopyRestoreBits.ShouldCopy : 1;
1446 friend class ASTReader;
1447 friend class ASTStmtReader;
1449 void setShouldCopy(bool shouldCopy) {
1450 ObjCIndirectCopyRestoreExprBits.ShouldCopy = shouldCopy;
1453 explicit ObjCIndirectCopyRestoreExpr(EmptyShell Empty)
1454 : Expr(ObjCIndirectCopyRestoreExprClass, Empty) { }
1457 ObjCIndirectCopyRestoreExpr(Expr *operand, QualType type, bool shouldCopy)
1458 : Expr(ObjCIndirectCopyRestoreExprClass, type, VK_LValue, OK_Ordinary,
1459 operand->isTypeDependent(), operand->isValueDependent(),
1460 operand->isInstantiationDependent(),
1461 operand->containsUnexpandedParameterPack()),
1463 setShouldCopy(shouldCopy);
1466 Expr *getSubExpr() { return cast<Expr>(Operand); }
1467 const Expr *getSubExpr() const { return cast<Expr>(Operand); }
1469 /// shouldCopy - True if we should do the 'copy' part of the
1470 /// copy-restore. If false, the temporary will be zero-initialized.
1471 bool shouldCopy() const { return ObjCIndirectCopyRestoreExprBits.ShouldCopy; }
1473 child_range children() { return child_range(&Operand, &Operand+1); }
1475 // Source locations are determined by the subexpression.
1476 SourceRange getSourceRange() const LLVM_READONLY {
1477 return Operand->getSourceRange();
1479 SourceLocation getExprLoc() const LLVM_READONLY {
1480 return getSubExpr()->getExprLoc();
1483 static bool classof(const Stmt *s) {
1484 return s->getStmtClass() == ObjCIndirectCopyRestoreExprClass;
1486 static bool classof(const ObjCIndirectCopyRestoreExpr *) { return true; }
1489 /// \brief An Objective-C "bridged" cast expression, which casts between
1490 /// Objective-C pointers and C pointers, transferring ownership in the process.
1493 /// NSString *str = (__bridge_transfer NSString *)CFCreateString();
1495 class ObjCBridgedCastExpr : public ExplicitCastExpr {
1496 SourceLocation LParenLoc;
1497 SourceLocation BridgeKeywordLoc;
1500 friend class ASTStmtReader;
1501 friend class ASTStmtWriter;
1504 ObjCBridgedCastExpr(SourceLocation LParenLoc, ObjCBridgeCastKind Kind,
1505 CastKind CK, SourceLocation BridgeKeywordLoc,
1506 TypeSourceInfo *TSInfo, Expr *Operand)
1507 : ExplicitCastExpr(ObjCBridgedCastExprClass, TSInfo->getType(), VK_RValue,
1508 CK, Operand, 0, TSInfo),
1509 LParenLoc(LParenLoc), BridgeKeywordLoc(BridgeKeywordLoc), Kind(Kind) { }
1511 /// \brief Construct an empty Objective-C bridged cast.
1512 explicit ObjCBridgedCastExpr(EmptyShell Shell)
1513 : ExplicitCastExpr(ObjCBridgedCastExprClass, Shell, 0) { }
1515 SourceLocation getLParenLoc() const { return LParenLoc; }
1517 /// \brief Determine which kind of bridge is being performed via this cast.
1518 ObjCBridgeCastKind getBridgeKind() const {
1519 return static_cast<ObjCBridgeCastKind>(Kind);
1522 /// \brief Retrieve the kind of bridge being performed as a string.
1523 StringRef getBridgeKindName() const;
1525 /// \brief The location of the bridge keyword.
1526 SourceLocation getBridgeKeywordLoc() const { return BridgeKeywordLoc; }
1528 SourceRange getSourceRange() const LLVM_READONLY {
1529 return SourceRange(LParenLoc, getSubExpr()->getLocEnd());
1532 static bool classof(const Stmt *T) {
1533 return T->getStmtClass() == ObjCBridgedCastExprClass;
1535 static bool classof(const ObjCBridgedCastExpr *) { return true; }
1539 } // end namespace clang