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