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