Details | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 14 | pmbaty | 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 |