1 //===- DeclObjC.h - Classes for representing declarations -------*- 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 DeclObjC interface and subclasses. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_CLANG_AST_DECLOBJC_H 14 #define LLVM_CLANG_AST_DECLOBJC_H 15 16 #include "clang/AST/Decl.h" 17 #include "clang/AST/DeclBase.h" 18 #include "clang/AST/DeclObjCCommon.h" 19 #include "clang/AST/ExternalASTSource.h" 20 #include "clang/AST/Redeclarable.h" 21 #include "clang/AST/SelectorLocationsKind.h" 22 #include "clang/AST/Type.h" 23 #include "clang/Basic/IdentifierTable.h" 24 #include "clang/Basic/LLVM.h" 25 #include "clang/Basic/SourceLocation.h" 26 #include "clang/Basic/Specifiers.h" 27 #include "llvm/ADT/ArrayRef.h" 28 #include "llvm/ADT/DenseSet.h" 29 #include "llvm/ADT/MapVector.h" 30 #include "llvm/ADT/PointerIntPair.h" 31 #include "llvm/ADT/STLExtras.h" 32 #include "llvm/ADT/StringRef.h" 33 #include "llvm/ADT/iterator_range.h" 34 #include "llvm/Support/Compiler.h" 35 #include "llvm/Support/TrailingObjects.h" 36 #include <cassert> 37 #include <cstddef> 38 #include <cstdint> 39 #include <iterator> 40 #include <string> 41 #include <utility> 42 43 namespace clang { 44 45 class ASTContext; 46 class CompoundStmt; 47 class CXXCtorInitializer; 48 class Expr; 49 class ObjCCategoryDecl; 50 class ObjCCategoryImplDecl; 51 class ObjCImplementationDecl; 52 class ObjCInterfaceDecl; 53 class ObjCIvarDecl; 54 class ObjCPropertyDecl; 55 class ObjCPropertyImplDecl; 56 class ObjCProtocolDecl; 57 class Stmt; 58 59 class ObjCListBase { 60 protected: 61 /// List is an array of pointers to objects that are not owned by this object. 62 void **List = nullptr; 63 unsigned NumElts = 0; 64 65 public: 66 ObjCListBase() = default; 67 ObjCListBase(const ObjCListBase &) = delete; 68 ObjCListBase &operator=(const ObjCListBase &) = delete; 69 70 unsigned size() const { return NumElts; } 71 bool empty() const { return NumElts == 0; } 72 73 protected: 74 void set(void *const* InList, unsigned Elts, ASTContext &Ctx); 75 }; 76 77 /// ObjCList - This is a simple template class used to hold various lists of 78 /// decls etc, which is heavily used by the ObjC front-end. This only use case 79 /// this supports is setting the list all at once and then reading elements out 80 /// of it. 81 template <typename T> 82 class ObjCList : public ObjCListBase { 83 public: 84 void set(T* const* InList, unsigned Elts, ASTContext &Ctx) { 85 ObjCListBase::set(reinterpret_cast<void*const*>(InList), Elts, Ctx); 86 } 87 88 using iterator = T* const *; 89 90 iterator begin() const { return (iterator)List; } 91 iterator end() const { return (iterator)List+NumElts; } 92 93 T* operator[](unsigned Idx) const { 94 assert(Idx < NumElts && "Invalid access"); 95 return (T*)List[Idx]; 96 } 97 }; 98 99 /// A list of Objective-C protocols, along with the source 100 /// locations at which they were referenced. 101 class ObjCProtocolList : public ObjCList<ObjCProtocolDecl> { 102 SourceLocation *Locations = nullptr; 103 104 using ObjCList<ObjCProtocolDecl>::set; 105 106 public: 107 ObjCProtocolList() = default; 108 109 using loc_iterator = const SourceLocation *; 110 111 loc_iterator loc_begin() const { return Locations; } 112 loc_iterator loc_end() const { return Locations + size(); } 113 114 void set(ObjCProtocolDecl* const* InList, unsigned Elts, 115 const SourceLocation *Locs, ASTContext &Ctx); 116 }; 117 118 /// ObjCMethodDecl - Represents an instance or class method declaration. 119 /// ObjC methods can be declared within 4 contexts: class interfaces, 120 /// categories, protocols, and class implementations. While C++ member 121 /// functions leverage C syntax, Objective-C method syntax is modeled after 122 /// Smalltalk (using colons to specify argument types/expressions). 123 /// Here are some brief examples: 124 /// 125 /// Setter/getter instance methods: 126 /// - (void)setMenu:(NSMenu *)menu; 127 /// - (NSMenu *)menu; 128 /// 129 /// Instance method that takes 2 NSView arguments: 130 /// - (void)replaceSubview:(NSView *)oldView with:(NSView *)newView; 131 /// 132 /// Getter class method: 133 /// + (NSMenu *)defaultMenu; 134 /// 135 /// A selector represents a unique name for a method. The selector names for 136 /// the above methods are setMenu:, menu, replaceSubview:with:, and defaultMenu. 137 /// 138 class ObjCMethodDecl : public NamedDecl, public DeclContext { 139 // This class stores some data in DeclContext::ObjCMethodDeclBits 140 // to save some space. Use the provided accessors to access it. 141 142 public: 143 enum ImplementationControl { None, Required, Optional }; 144 145 private: 146 /// Return type of this method. 147 QualType MethodDeclType; 148 149 /// Type source information for the return type. 150 TypeSourceInfo *ReturnTInfo; 151 152 /// Array of ParmVarDecls for the formal parameters of this method 153 /// and optionally followed by selector locations. 154 void *ParamsAndSelLocs = nullptr; 155 unsigned NumParams = 0; 156 157 /// List of attributes for this method declaration. 158 SourceLocation DeclEndLoc; // the location of the ';' or '{'. 159 160 /// The following are only used for method definitions, null otherwise. 161 LazyDeclStmtPtr Body; 162 163 /// SelfDecl - Decl for the implicit self parameter. This is lazily 164 /// constructed by createImplicitParams. 165 ImplicitParamDecl *SelfDecl = nullptr; 166 167 /// CmdDecl - Decl for the implicit _cmd parameter. This is lazily 168 /// constructed by createImplicitParams. 169 ImplicitParamDecl *CmdDecl = nullptr; 170 171 ObjCMethodDecl(SourceLocation beginLoc, SourceLocation endLoc, 172 Selector SelInfo, QualType T, TypeSourceInfo *ReturnTInfo, 173 DeclContext *contextDecl, bool isInstance = true, 174 bool isVariadic = false, bool isPropertyAccessor = false, 175 bool isSynthesizedAccessorStub = false, 176 bool isImplicitlyDeclared = false, bool isDefined = false, 177 ImplementationControl impControl = None, 178 bool HasRelatedResultType = false); 179 180 SelectorLocationsKind getSelLocsKind() const { 181 return static_cast<SelectorLocationsKind>(ObjCMethodDeclBits.SelLocsKind); 182 } 183 184 void setSelLocsKind(SelectorLocationsKind Kind) { 185 ObjCMethodDeclBits.SelLocsKind = Kind; 186 } 187 188 bool hasStandardSelLocs() const { 189 return getSelLocsKind() != SelLoc_NonStandard; 190 } 191 192 /// Get a pointer to the stored selector identifiers locations array. 193 /// No locations will be stored if HasStandardSelLocs is true. 194 SourceLocation *getStoredSelLocs() { 195 return reinterpret_cast<SourceLocation *>(getParams() + NumParams); 196 } 197 const SourceLocation *getStoredSelLocs() const { 198 return reinterpret_cast<const SourceLocation *>(getParams() + NumParams); 199 } 200 201 /// Get a pointer to the stored selector identifiers locations array. 202 /// No locations will be stored if HasStandardSelLocs is true. 203 ParmVarDecl **getParams() { 204 return reinterpret_cast<ParmVarDecl **>(ParamsAndSelLocs); 205 } 206 const ParmVarDecl *const *getParams() const { 207 return reinterpret_cast<const ParmVarDecl *const *>(ParamsAndSelLocs); 208 } 209 210 /// Get the number of stored selector identifiers locations. 211 /// No locations will be stored if HasStandardSelLocs is true. 212 unsigned getNumStoredSelLocs() const { 213 if (hasStandardSelLocs()) 214 return 0; 215 return getNumSelectorLocs(); 216 } 217 218 void setParamsAndSelLocs(ASTContext &C, 219 ArrayRef<ParmVarDecl*> Params, 220 ArrayRef<SourceLocation> SelLocs); 221 222 /// A definition will return its interface declaration. 223 /// An interface declaration will return its definition. 224 /// Otherwise it will return itself. 225 ObjCMethodDecl *getNextRedeclarationImpl() override; 226 227 public: 228 friend class ASTDeclReader; 229 friend class ASTDeclWriter; 230 231 static ObjCMethodDecl * 232 Create(ASTContext &C, SourceLocation beginLoc, SourceLocation endLoc, 233 Selector SelInfo, QualType T, TypeSourceInfo *ReturnTInfo, 234 DeclContext *contextDecl, bool isInstance = true, 235 bool isVariadic = false, bool isPropertyAccessor = false, 236 bool isSynthesizedAccessorStub = false, 237 bool isImplicitlyDeclared = false, bool isDefined = false, 238 ImplementationControl impControl = None, 239 bool HasRelatedResultType = false); 240 241 static ObjCMethodDecl *CreateDeserialized(ASTContext &C, unsigned ID); 242 243 ObjCMethodDecl *getCanonicalDecl() override; 244 const ObjCMethodDecl *getCanonicalDecl() const { 245 return const_cast<ObjCMethodDecl*>(this)->getCanonicalDecl(); 246 } 247 248 ObjCDeclQualifier getObjCDeclQualifier() const { 249 return static_cast<ObjCDeclQualifier>(ObjCMethodDeclBits.objcDeclQualifier); 250 } 251 252 void setObjCDeclQualifier(ObjCDeclQualifier QV) { 253 ObjCMethodDeclBits.objcDeclQualifier = QV; 254 } 255 256 /// Determine whether this method has a result type that is related 257 /// to the message receiver's type. 258 bool hasRelatedResultType() const { 259 return ObjCMethodDeclBits.RelatedResultType; 260 } 261 262 /// Note whether this method has a related result type. 263 void setRelatedResultType(bool RRT = true) { 264 ObjCMethodDeclBits.RelatedResultType = RRT; 265 } 266 267 /// True if this is a method redeclaration in the same interface. 268 bool isRedeclaration() const { return ObjCMethodDeclBits.IsRedeclaration; } 269 void setIsRedeclaration(bool RD) { ObjCMethodDeclBits.IsRedeclaration = RD; } 270 void setAsRedeclaration(const ObjCMethodDecl *PrevMethod); 271 272 /// True if redeclared in the same interface. 273 bool hasRedeclaration() const { return ObjCMethodDeclBits.HasRedeclaration; } 274 void setHasRedeclaration(bool HRD) const { 275 ObjCMethodDeclBits.HasRedeclaration = HRD; 276 } 277 278 /// Returns the location where the declarator ends. It will be 279 /// the location of ';' for a method declaration and the location of '{' 280 /// for a method definition. 281 SourceLocation getDeclaratorEndLoc() const { return DeclEndLoc; } 282 283 // Location information, modeled after the Stmt API. 284 SourceLocation getBeginLoc() const LLVM_READONLY { return getLocation(); } 285 SourceLocation getEndLoc() const LLVM_READONLY; 286 SourceRange getSourceRange() const override LLVM_READONLY { 287 return SourceRange(getLocation(), getEndLoc()); 288 } 289 290 SourceLocation getSelectorStartLoc() const { 291 if (isImplicit()) 292 return getBeginLoc(); 293 return getSelectorLoc(0); 294 } 295 296 SourceLocation getSelectorLoc(unsigned Index) const { 297 assert(Index < getNumSelectorLocs() && "Index out of range!"); 298 if (hasStandardSelLocs()) 299 return getStandardSelectorLoc(Index, getSelector(), 300 getSelLocsKind() == SelLoc_StandardWithSpace, 301 parameters(), 302 DeclEndLoc); 303 return getStoredSelLocs()[Index]; 304 } 305 306 void getSelectorLocs(SmallVectorImpl<SourceLocation> &SelLocs) const; 307 308 unsigned getNumSelectorLocs() const { 309 if (isImplicit()) 310 return 0; 311 Selector Sel = getSelector(); 312 if (Sel.isUnarySelector()) 313 return 1; 314 return Sel.getNumArgs(); 315 } 316 317 ObjCInterfaceDecl *getClassInterface(); 318 const ObjCInterfaceDecl *getClassInterface() const { 319 return const_cast<ObjCMethodDecl*>(this)->getClassInterface(); 320 } 321 322 /// If this method is declared or implemented in a category, return 323 /// that category. 324 ObjCCategoryDecl *getCategory(); 325 const ObjCCategoryDecl *getCategory() const { 326 return const_cast<ObjCMethodDecl*>(this)->getCategory(); 327 } 328 329 Selector getSelector() const { return getDeclName().getObjCSelector(); } 330 331 QualType getReturnType() const { return MethodDeclType; } 332 void setReturnType(QualType T) { MethodDeclType = T; } 333 SourceRange getReturnTypeSourceRange() const; 334 335 /// Determine the type of an expression that sends a message to this 336 /// function. This replaces the type parameters with the types they would 337 /// get if the receiver was parameterless (e.g. it may replace the type 338 /// parameter with 'id'). 339 QualType getSendResultType() const; 340 341 /// Determine the type of an expression that sends a message to this 342 /// function with the given receiver type. 343 QualType getSendResultType(QualType receiverType) const; 344 345 TypeSourceInfo *getReturnTypeSourceInfo() const { return ReturnTInfo; } 346 void setReturnTypeSourceInfo(TypeSourceInfo *TInfo) { ReturnTInfo = TInfo; } 347 348 // Iterator access to formal parameters. 349 unsigned param_size() const { return NumParams; } 350 351 using param_const_iterator = const ParmVarDecl *const *; 352 using param_iterator = ParmVarDecl *const *; 353 using param_range = llvm::iterator_range<param_iterator>; 354 using param_const_range = llvm::iterator_range<param_const_iterator>; 355 356 param_const_iterator param_begin() const { 357 return param_const_iterator(getParams()); 358 } 359 360 param_const_iterator param_end() const { 361 return param_const_iterator(getParams() + NumParams); 362 } 363 364 param_iterator param_begin() { return param_iterator(getParams()); } 365 param_iterator param_end() { return param_iterator(getParams() + NumParams); } 366 367 // This method returns and of the parameters which are part of the selector 368 // name mangling requirements. 369 param_const_iterator sel_param_end() const { 370 return param_begin() + getSelector().getNumArgs(); 371 } 372 373 // ArrayRef access to formal parameters. This should eventually 374 // replace the iterator interface above. 375 ArrayRef<ParmVarDecl*> parameters() const { 376 return llvm::ArrayRef(const_cast<ParmVarDecl **>(getParams()), NumParams); 377 } 378 379 ParmVarDecl *getParamDecl(unsigned Idx) { 380 assert(Idx < NumParams && "Index out of bounds!"); 381 return getParams()[Idx]; 382 } 383 const ParmVarDecl *getParamDecl(unsigned Idx) const { 384 return const_cast<ObjCMethodDecl *>(this)->getParamDecl(Idx); 385 } 386 387 /// Sets the method's parameters and selector source locations. 388 /// If the method is implicit (not coming from source) \p SelLocs is 389 /// ignored. 390 void setMethodParams(ASTContext &C, ArrayRef<ParmVarDecl *> Params, 391 ArrayRef<SourceLocation> SelLocs = std::nullopt); 392 393 // Iterator access to parameter types. 394 struct GetTypeFn { 395 QualType operator()(const ParmVarDecl *PD) const { return PD->getType(); } 396 }; 397 398 using param_type_iterator = 399 llvm::mapped_iterator<param_const_iterator, GetTypeFn>; 400 401 param_type_iterator param_type_begin() const { 402 return llvm::map_iterator(param_begin(), GetTypeFn()); 403 } 404 405 param_type_iterator param_type_end() const { 406 return llvm::map_iterator(param_end(), GetTypeFn()); 407 } 408 409 /// createImplicitParams - Used to lazily create the self and cmd 410 /// implicit parameters. This must be called prior to using getSelfDecl() 411 /// or getCmdDecl(). The call is ignored if the implicit parameters 412 /// have already been created. 413 void createImplicitParams(ASTContext &Context, const ObjCInterfaceDecl *ID); 414 415 /// \return the type for \c self and set \arg selfIsPseudoStrong and 416 /// \arg selfIsConsumed accordingly. 417 QualType getSelfType(ASTContext &Context, const ObjCInterfaceDecl *OID, 418 bool &selfIsPseudoStrong, bool &selfIsConsumed) const; 419 420 ImplicitParamDecl * getSelfDecl() const { return SelfDecl; } 421 void setSelfDecl(ImplicitParamDecl *SD) { SelfDecl = SD; } 422 ImplicitParamDecl * getCmdDecl() const { return CmdDecl; } 423 void setCmdDecl(ImplicitParamDecl *CD) { CmdDecl = CD; } 424 425 /// Determines the family of this method. 426 ObjCMethodFamily getMethodFamily() const; 427 428 bool isInstanceMethod() const { return ObjCMethodDeclBits.IsInstance; } 429 void setInstanceMethod(bool isInst) { 430 ObjCMethodDeclBits.IsInstance = isInst; 431 } 432 433 bool isVariadic() const { return ObjCMethodDeclBits.IsVariadic; } 434 void setVariadic(bool isVar) { ObjCMethodDeclBits.IsVariadic = isVar; } 435 436 bool isClassMethod() const { return !isInstanceMethod(); } 437 438 bool isPropertyAccessor() const { 439 return ObjCMethodDeclBits.IsPropertyAccessor; 440 } 441 442 void setPropertyAccessor(bool isAccessor) { 443 ObjCMethodDeclBits.IsPropertyAccessor = isAccessor; 444 } 445 446 bool isSynthesizedAccessorStub() const { 447 return ObjCMethodDeclBits.IsSynthesizedAccessorStub; 448 } 449 450 void setSynthesizedAccessorStub(bool isSynthesizedAccessorStub) { 451 ObjCMethodDeclBits.IsSynthesizedAccessorStub = isSynthesizedAccessorStub; 452 } 453 454 bool isDefined() const { return ObjCMethodDeclBits.IsDefined; } 455 void setDefined(bool isDefined) { ObjCMethodDeclBits.IsDefined = isDefined; } 456 457 /// Whether this method overrides any other in the class hierarchy. 458 /// 459 /// A method is said to override any method in the class's 460 /// base classes, its protocols, or its categories' protocols, that has 461 /// the same selector and is of the same kind (class or instance). 462 /// A method in an implementation is not considered as overriding the same 463 /// method in the interface or its categories. 464 bool isOverriding() const { return ObjCMethodDeclBits.IsOverriding; } 465 void setOverriding(bool IsOver) { ObjCMethodDeclBits.IsOverriding = IsOver; } 466 467 /// Return overridden methods for the given \p Method. 468 /// 469 /// An ObjC method is considered to override any method in the class's 470 /// base classes (and base's categories), its protocols, or its categories' 471 /// protocols, that has 472 /// the same selector and is of the same kind (class or instance). 473 /// A method in an implementation is not considered as overriding the same 474 /// method in the interface or its categories. 475 void getOverriddenMethods( 476 SmallVectorImpl<const ObjCMethodDecl *> &Overridden) const; 477 478 /// True if the method was a definition but its body was skipped. 479 bool hasSkippedBody() const { return ObjCMethodDeclBits.HasSkippedBody; } 480 void setHasSkippedBody(bool Skipped = true) { 481 ObjCMethodDeclBits.HasSkippedBody = Skipped; 482 } 483 484 /// True if the method is tagged as objc_direct 485 bool isDirectMethod() const; 486 487 /// True if the method has a parameter that's destroyed in the callee. 488 bool hasParamDestroyedInCallee() const; 489 490 /// Returns the property associated with this method's selector. 491 /// 492 /// Note that even if this particular method is not marked as a property 493 /// accessor, it is still possible for it to match a property declared in a 494 /// superclass. Pass \c false if you only want to check the current class. 495 const ObjCPropertyDecl *findPropertyDecl(bool CheckOverrides = true) const; 496 497 // Related to protocols declared in \@protocol 498 void setDeclImplementation(ImplementationControl ic) { 499 ObjCMethodDeclBits.DeclImplementation = ic; 500 } 501 502 ImplementationControl getImplementationControl() const { 503 return ImplementationControl(ObjCMethodDeclBits.DeclImplementation); 504 } 505 506 bool isOptional() const { 507 return getImplementationControl() == Optional; 508 } 509 510 /// Returns true if this specific method declaration is marked with the 511 /// designated initializer attribute. 512 bool isThisDeclarationADesignatedInitializer() const; 513 514 /// Returns true if the method selector resolves to a designated initializer 515 /// in the class's interface. 516 /// 517 /// \param InitMethod if non-null and the function returns true, it receives 518 /// the method declaration that was marked with the designated initializer 519 /// attribute. 520 bool isDesignatedInitializerForTheInterface( 521 const ObjCMethodDecl **InitMethod = nullptr) const; 522 523 /// Determine whether this method has a body. 524 bool hasBody() const override { return Body.isValid(); } 525 526 /// Retrieve the body of this method, if it has one. 527 Stmt *getBody() const override; 528 529 void setLazyBody(uint64_t Offset) { Body = Offset; } 530 531 CompoundStmt *getCompoundBody() { return (CompoundStmt*)getBody(); } 532 void setBody(Stmt *B) { Body = B; } 533 534 /// Returns whether this specific method is a definition. 535 bool isThisDeclarationADefinition() const { return hasBody(); } 536 537 /// Is this method defined in the NSObject base class? 538 bool definedInNSObject(const ASTContext &) const; 539 540 // Implement isa/cast/dyncast/etc. 541 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 542 static bool classofKind(Kind K) { return K == ObjCMethod; } 543 544 static DeclContext *castToDeclContext(const ObjCMethodDecl *D) { 545 return static_cast<DeclContext *>(const_cast<ObjCMethodDecl*>(D)); 546 } 547 548 static ObjCMethodDecl *castFromDeclContext(const DeclContext *DC) { 549 return static_cast<ObjCMethodDecl *>(const_cast<DeclContext*>(DC)); 550 } 551 }; 552 553 /// Describes the variance of a given generic parameter. 554 enum class ObjCTypeParamVariance : uint8_t { 555 /// The parameter is invariant: must match exactly. 556 Invariant, 557 558 /// The parameter is covariant, e.g., X<T> is a subtype of X<U> when 559 /// the type parameter is covariant and T is a subtype of U. 560 Covariant, 561 562 /// The parameter is contravariant, e.g., X<T> is a subtype of X<U> 563 /// when the type parameter is covariant and U is a subtype of T. 564 Contravariant, 565 }; 566 567 /// Represents the declaration of an Objective-C type parameter. 568 /// 569 /// \code 570 /// @interface NSDictionary<Key : id<NSCopying>, Value> 571 /// @end 572 /// \endcode 573 /// 574 /// In the example above, both \c Key and \c Value are represented by 575 /// \c ObjCTypeParamDecl. \c Key has an explicit bound of \c id<NSCopying>, 576 /// while \c Value gets an implicit bound of \c id. 577 /// 578 /// Objective-C type parameters are typedef-names in the grammar, 579 class ObjCTypeParamDecl : public TypedefNameDecl { 580 /// Index of this type parameter in the type parameter list. 581 unsigned Index : 14; 582 583 /// The variance of the type parameter. 584 unsigned Variance : 2; 585 586 /// The location of the variance, if any. 587 SourceLocation VarianceLoc; 588 589 /// The location of the ':', which will be valid when the bound was 590 /// explicitly specified. 591 SourceLocation ColonLoc; 592 593 ObjCTypeParamDecl(ASTContext &ctx, DeclContext *dc, 594 ObjCTypeParamVariance variance, SourceLocation varianceLoc, 595 unsigned index, 596 SourceLocation nameLoc, IdentifierInfo *name, 597 SourceLocation colonLoc, TypeSourceInfo *boundInfo) 598 : TypedefNameDecl(ObjCTypeParam, ctx, dc, nameLoc, nameLoc, name, 599 boundInfo), 600 Index(index), Variance(static_cast<unsigned>(variance)), 601 VarianceLoc(varianceLoc), ColonLoc(colonLoc) {} 602 603 void anchor() override; 604 605 public: 606 friend class ASTDeclReader; 607 friend class ASTDeclWriter; 608 609 static ObjCTypeParamDecl *Create(ASTContext &ctx, DeclContext *dc, 610 ObjCTypeParamVariance variance, 611 SourceLocation varianceLoc, 612 unsigned index, 613 SourceLocation nameLoc, 614 IdentifierInfo *name, 615 SourceLocation colonLoc, 616 TypeSourceInfo *boundInfo); 617 static ObjCTypeParamDecl *CreateDeserialized(ASTContext &ctx, unsigned ID); 618 619 SourceRange getSourceRange() const override LLVM_READONLY; 620 621 /// Determine the variance of this type parameter. 622 ObjCTypeParamVariance getVariance() const { 623 return static_cast<ObjCTypeParamVariance>(Variance); 624 } 625 626 /// Set the variance of this type parameter. 627 void setVariance(ObjCTypeParamVariance variance) { 628 Variance = static_cast<unsigned>(variance); 629 } 630 631 /// Retrieve the location of the variance keyword. 632 SourceLocation getVarianceLoc() const { return VarianceLoc; } 633 634 /// Retrieve the index into its type parameter list. 635 unsigned getIndex() const { return Index; } 636 637 /// Whether this type parameter has an explicitly-written type bound, e.g., 638 /// "T : NSView". 639 bool hasExplicitBound() const { return ColonLoc.isValid(); } 640 641 /// Retrieve the location of the ':' separating the type parameter name 642 /// from the explicitly-specified bound. 643 SourceLocation getColonLoc() const { return ColonLoc; } 644 645 // Implement isa/cast/dyncast/etc. 646 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 647 static bool classofKind(Kind K) { return K == ObjCTypeParam; } 648 }; 649 650 /// Stores a list of Objective-C type parameters for a parameterized class 651 /// or a category/extension thereof. 652 /// 653 /// \code 654 /// @interface NSArray<T> // stores the <T> 655 /// @end 656 /// \endcode 657 class ObjCTypeParamList final 658 : private llvm::TrailingObjects<ObjCTypeParamList, ObjCTypeParamDecl *> { 659 /// Location of the left and right angle brackets. 660 SourceRange Brackets; 661 /// The number of parameters in the list, which are tail-allocated. 662 unsigned NumParams; 663 664 ObjCTypeParamList(SourceLocation lAngleLoc, 665 ArrayRef<ObjCTypeParamDecl *> typeParams, 666 SourceLocation rAngleLoc); 667 668 public: 669 friend TrailingObjects; 670 671 /// Create a new Objective-C type parameter list. 672 static ObjCTypeParamList *create(ASTContext &ctx, 673 SourceLocation lAngleLoc, 674 ArrayRef<ObjCTypeParamDecl *> typeParams, 675 SourceLocation rAngleLoc); 676 677 /// Iterate through the type parameters in the list. 678 using iterator = ObjCTypeParamDecl **; 679 680 iterator begin() { return getTrailingObjects<ObjCTypeParamDecl *>(); } 681 682 iterator end() { return begin() + size(); } 683 684 /// Determine the number of type parameters in this list. 685 unsigned size() const { return NumParams; } 686 687 // Iterate through the type parameters in the list. 688 using const_iterator = ObjCTypeParamDecl * const *; 689 690 const_iterator begin() const { 691 return getTrailingObjects<ObjCTypeParamDecl *>(); 692 } 693 694 const_iterator end() const { 695 return begin() + size(); 696 } 697 698 ObjCTypeParamDecl *front() const { 699 assert(size() > 0 && "empty Objective-C type parameter list"); 700 return *begin(); 701 } 702 703 ObjCTypeParamDecl *back() const { 704 assert(size() > 0 && "empty Objective-C type parameter list"); 705 return *(end() - 1); 706 } 707 708 SourceLocation getLAngleLoc() const { return Brackets.getBegin(); } 709 SourceLocation getRAngleLoc() const { return Brackets.getEnd(); } 710 SourceRange getSourceRange() const { return Brackets; } 711 712 /// Gather the default set of type arguments to be substituted for 713 /// these type parameters when dealing with an unspecialized type. 714 void gatherDefaultTypeArgs(SmallVectorImpl<QualType> &typeArgs) const; 715 }; 716 717 enum class ObjCPropertyQueryKind : uint8_t { 718 OBJC_PR_query_unknown = 0x00, 719 OBJC_PR_query_instance, 720 OBJC_PR_query_class 721 }; 722 723 /// Represents one property declaration in an Objective-C interface. 724 /// 725 /// For example: 726 /// \code{.mm} 727 /// \@property (assign, readwrite) int MyProperty; 728 /// \endcode 729 class ObjCPropertyDecl : public NamedDecl { 730 void anchor() override; 731 732 public: 733 enum SetterKind { Assign, Retain, Copy, Weak }; 734 enum PropertyControl { None, Required, Optional }; 735 736 private: 737 // location of \@property 738 SourceLocation AtLoc; 739 740 // location of '(' starting attribute list or null. 741 SourceLocation LParenLoc; 742 743 QualType DeclType; 744 TypeSourceInfo *DeclTypeSourceInfo; 745 unsigned PropertyAttributes : NumObjCPropertyAttrsBits; 746 unsigned PropertyAttributesAsWritten : NumObjCPropertyAttrsBits; 747 748 // \@required/\@optional 749 unsigned PropertyImplementation : 2; 750 751 // getter name of NULL if no getter 752 Selector GetterName; 753 754 // setter name of NULL if no setter 755 Selector SetterName; 756 757 // location of the getter attribute's value 758 SourceLocation GetterNameLoc; 759 760 // location of the setter attribute's value 761 SourceLocation SetterNameLoc; 762 763 // Declaration of getter instance method 764 ObjCMethodDecl *GetterMethodDecl = nullptr; 765 766 // Declaration of setter instance method 767 ObjCMethodDecl *SetterMethodDecl = nullptr; 768 769 // Synthesize ivar for this property 770 ObjCIvarDecl *PropertyIvarDecl = nullptr; 771 772 ObjCPropertyDecl(DeclContext *DC, SourceLocation L, IdentifierInfo *Id, 773 SourceLocation AtLocation, SourceLocation LParenLocation, 774 QualType T, TypeSourceInfo *TSI, PropertyControl propControl) 775 : NamedDecl(ObjCProperty, DC, L, Id), AtLoc(AtLocation), 776 LParenLoc(LParenLocation), DeclType(T), DeclTypeSourceInfo(TSI), 777 PropertyAttributes(ObjCPropertyAttribute::kind_noattr), 778 PropertyAttributesAsWritten(ObjCPropertyAttribute::kind_noattr), 779 PropertyImplementation(propControl) {} 780 781 public: 782 static ObjCPropertyDecl * 783 Create(ASTContext &C, DeclContext *DC, SourceLocation L, IdentifierInfo *Id, 784 SourceLocation AtLocation, SourceLocation LParenLocation, QualType T, 785 TypeSourceInfo *TSI, PropertyControl propControl = None); 786 787 static ObjCPropertyDecl *CreateDeserialized(ASTContext &C, unsigned ID); 788 789 SourceLocation getAtLoc() const { return AtLoc; } 790 void setAtLoc(SourceLocation L) { AtLoc = L; } 791 792 SourceLocation getLParenLoc() const { return LParenLoc; } 793 void setLParenLoc(SourceLocation L) { LParenLoc = L; } 794 795 TypeSourceInfo *getTypeSourceInfo() const { return DeclTypeSourceInfo; } 796 797 QualType getType() const { return DeclType; } 798 799 void setType(QualType T, TypeSourceInfo *TSI) { 800 DeclType = T; 801 DeclTypeSourceInfo = TSI; 802 } 803 804 /// Retrieve the type when this property is used with a specific base object 805 /// type. 806 QualType getUsageType(QualType objectType) const; 807 808 ObjCPropertyAttribute::Kind getPropertyAttributes() const { 809 return ObjCPropertyAttribute::Kind(PropertyAttributes); 810 } 811 812 void setPropertyAttributes(ObjCPropertyAttribute::Kind PRVal) { 813 PropertyAttributes |= PRVal; 814 } 815 816 void overwritePropertyAttributes(unsigned PRVal) { 817 PropertyAttributes = PRVal; 818 } 819 820 ObjCPropertyAttribute::Kind getPropertyAttributesAsWritten() const { 821 return ObjCPropertyAttribute::Kind(PropertyAttributesAsWritten); 822 } 823 824 void setPropertyAttributesAsWritten(ObjCPropertyAttribute::Kind PRVal) { 825 PropertyAttributesAsWritten = PRVal; 826 } 827 828 // Helper methods for accessing attributes. 829 830 /// isReadOnly - Return true iff the property has a setter. 831 bool isReadOnly() const { 832 return (PropertyAttributes & ObjCPropertyAttribute::kind_readonly); 833 } 834 835 /// isAtomic - Return true if the property is atomic. 836 bool isAtomic() const { 837 return (PropertyAttributes & ObjCPropertyAttribute::kind_atomic); 838 } 839 840 /// isRetaining - Return true if the property retains its value. 841 bool isRetaining() const { 842 return (PropertyAttributes & (ObjCPropertyAttribute::kind_retain | 843 ObjCPropertyAttribute::kind_strong | 844 ObjCPropertyAttribute::kind_copy)); 845 } 846 847 bool isInstanceProperty() const { return !isClassProperty(); } 848 bool isClassProperty() const { 849 return PropertyAttributes & ObjCPropertyAttribute::kind_class; 850 } 851 bool isDirectProperty() const; 852 853 ObjCPropertyQueryKind getQueryKind() const { 854 return isClassProperty() ? ObjCPropertyQueryKind::OBJC_PR_query_class : 855 ObjCPropertyQueryKind::OBJC_PR_query_instance; 856 } 857 858 static ObjCPropertyQueryKind getQueryKind(bool isClassProperty) { 859 return isClassProperty ? ObjCPropertyQueryKind::OBJC_PR_query_class : 860 ObjCPropertyQueryKind::OBJC_PR_query_instance; 861 } 862 863 /// getSetterKind - Return the method used for doing assignment in 864 /// the property setter. This is only valid if the property has been 865 /// defined to have a setter. 866 SetterKind getSetterKind() const { 867 if (PropertyAttributes & ObjCPropertyAttribute::kind_strong) 868 return getType()->isBlockPointerType() ? Copy : Retain; 869 if (PropertyAttributes & ObjCPropertyAttribute::kind_retain) 870 return Retain; 871 if (PropertyAttributes & ObjCPropertyAttribute::kind_copy) 872 return Copy; 873 if (PropertyAttributes & ObjCPropertyAttribute::kind_weak) 874 return Weak; 875 return Assign; 876 } 877 878 Selector getGetterName() const { return GetterName; } 879 SourceLocation getGetterNameLoc() const { return GetterNameLoc; } 880 881 void setGetterName(Selector Sel, SourceLocation Loc = SourceLocation()) { 882 GetterName = Sel; 883 GetterNameLoc = Loc; 884 } 885 886 Selector getSetterName() const { return SetterName; } 887 SourceLocation getSetterNameLoc() const { return SetterNameLoc; } 888 889 void setSetterName(Selector Sel, SourceLocation Loc = SourceLocation()) { 890 SetterName = Sel; 891 SetterNameLoc = Loc; 892 } 893 894 ObjCMethodDecl *getGetterMethodDecl() const { return GetterMethodDecl; } 895 void setGetterMethodDecl(ObjCMethodDecl *gDecl) { GetterMethodDecl = gDecl; } 896 897 ObjCMethodDecl *getSetterMethodDecl() const { return SetterMethodDecl; } 898 void setSetterMethodDecl(ObjCMethodDecl *gDecl) { SetterMethodDecl = gDecl; } 899 900 // Related to \@optional/\@required declared in \@protocol 901 void setPropertyImplementation(PropertyControl pc) { 902 PropertyImplementation = pc; 903 } 904 905 PropertyControl getPropertyImplementation() const { 906 return PropertyControl(PropertyImplementation); 907 } 908 909 bool isOptional() const { 910 return getPropertyImplementation() == PropertyControl::Optional; 911 } 912 913 void setPropertyIvarDecl(ObjCIvarDecl *Ivar) { 914 PropertyIvarDecl = Ivar; 915 } 916 917 ObjCIvarDecl *getPropertyIvarDecl() const { 918 return PropertyIvarDecl; 919 } 920 921 SourceRange getSourceRange() const override LLVM_READONLY { 922 return SourceRange(AtLoc, getLocation()); 923 } 924 925 /// Get the default name of the synthesized ivar. 926 IdentifierInfo *getDefaultSynthIvarName(ASTContext &Ctx) const; 927 928 /// Lookup a property by name in the specified DeclContext. 929 static ObjCPropertyDecl *findPropertyDecl(const DeclContext *DC, 930 const IdentifierInfo *propertyID, 931 ObjCPropertyQueryKind queryKind); 932 933 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 934 static bool classofKind(Kind K) { return K == ObjCProperty; } 935 }; 936 937 /// ObjCContainerDecl - Represents a container for method declarations. 938 /// Current sub-classes are ObjCInterfaceDecl, ObjCCategoryDecl, 939 /// ObjCProtocolDecl, and ObjCImplDecl. 940 /// 941 class ObjCContainerDecl : public NamedDecl, public DeclContext { 942 // This class stores some data in DeclContext::ObjCContainerDeclBits 943 // to save some space. Use the provided accessors to access it. 944 945 // These two locations in the range mark the end of the method container. 946 // The first points to the '@' token, and the second to the 'end' token. 947 SourceRange AtEnd; 948 949 void anchor() override; 950 951 public: 952 ObjCContainerDecl(Kind DK, DeclContext *DC, IdentifierInfo *Id, 953 SourceLocation nameLoc, SourceLocation atStartLoc); 954 955 // Iterator access to instance/class properties. 956 using prop_iterator = specific_decl_iterator<ObjCPropertyDecl>; 957 using prop_range = 958 llvm::iterator_range<specific_decl_iterator<ObjCPropertyDecl>>; 959 960 prop_range properties() const { return prop_range(prop_begin(), prop_end()); } 961 962 prop_iterator prop_begin() const { 963 return prop_iterator(decls_begin()); 964 } 965 966 prop_iterator prop_end() const { 967 return prop_iterator(decls_end()); 968 } 969 970 using instprop_iterator = 971 filtered_decl_iterator<ObjCPropertyDecl, 972 &ObjCPropertyDecl::isInstanceProperty>; 973 using instprop_range = llvm::iterator_range<instprop_iterator>; 974 975 instprop_range instance_properties() const { 976 return instprop_range(instprop_begin(), instprop_end()); 977 } 978 979 instprop_iterator instprop_begin() const { 980 return instprop_iterator(decls_begin()); 981 } 982 983 instprop_iterator instprop_end() const { 984 return instprop_iterator(decls_end()); 985 } 986 987 using classprop_iterator = 988 filtered_decl_iterator<ObjCPropertyDecl, 989 &ObjCPropertyDecl::isClassProperty>; 990 using classprop_range = llvm::iterator_range<classprop_iterator>; 991 992 classprop_range class_properties() const { 993 return classprop_range(classprop_begin(), classprop_end()); 994 } 995 996 classprop_iterator classprop_begin() const { 997 return classprop_iterator(decls_begin()); 998 } 999 1000 classprop_iterator classprop_end() const { 1001 return classprop_iterator(decls_end()); 1002 } 1003 1004 // Iterator access to instance/class methods. 1005 using method_iterator = specific_decl_iterator<ObjCMethodDecl>; 1006 using method_range = 1007 llvm::iterator_range<specific_decl_iterator<ObjCMethodDecl>>; 1008 1009 method_range methods() const { 1010 return method_range(meth_begin(), meth_end()); 1011 } 1012 1013 method_iterator meth_begin() const { 1014 return method_iterator(decls_begin()); 1015 } 1016 1017 method_iterator meth_end() const { 1018 return method_iterator(decls_end()); 1019 } 1020 1021 using instmeth_iterator = 1022 filtered_decl_iterator<ObjCMethodDecl, 1023 &ObjCMethodDecl::isInstanceMethod>; 1024 using instmeth_range = llvm::iterator_range<instmeth_iterator>; 1025 1026 instmeth_range instance_methods() const { 1027 return instmeth_range(instmeth_begin(), instmeth_end()); 1028 } 1029 1030 instmeth_iterator instmeth_begin() const { 1031 return instmeth_iterator(decls_begin()); 1032 } 1033 1034 instmeth_iterator instmeth_end() const { 1035 return instmeth_iterator(decls_end()); 1036 } 1037 1038 using classmeth_iterator = 1039 filtered_decl_iterator<ObjCMethodDecl, 1040 &ObjCMethodDecl::isClassMethod>; 1041 using classmeth_range = llvm::iterator_range<classmeth_iterator>; 1042 1043 classmeth_range class_methods() const { 1044 return classmeth_range(classmeth_begin(), classmeth_end()); 1045 } 1046 1047 classmeth_iterator classmeth_begin() const { 1048 return classmeth_iterator(decls_begin()); 1049 } 1050 1051 classmeth_iterator classmeth_end() const { 1052 return classmeth_iterator(decls_end()); 1053 } 1054 1055 // Get the local instance/class method declared in this interface. 1056 ObjCMethodDecl *getMethod(Selector Sel, bool isInstance, 1057 bool AllowHidden = false) const; 1058 1059 ObjCMethodDecl *getInstanceMethod(Selector Sel, 1060 bool AllowHidden = false) const { 1061 return getMethod(Sel, true/*isInstance*/, AllowHidden); 1062 } 1063 1064 ObjCMethodDecl *getClassMethod(Selector Sel, bool AllowHidden = false) const { 1065 return getMethod(Sel, false/*isInstance*/, AllowHidden); 1066 } 1067 1068 bool HasUserDeclaredSetterMethod(const ObjCPropertyDecl *P) const; 1069 ObjCIvarDecl *getIvarDecl(IdentifierInfo *Id) const; 1070 1071 ObjCPropertyDecl *getProperty(const IdentifierInfo *Id, 1072 bool IsInstance) const; 1073 1074 ObjCPropertyDecl * 1075 FindPropertyDeclaration(const IdentifierInfo *PropertyId, 1076 ObjCPropertyQueryKind QueryKind) const; 1077 1078 using PropertyMap = 1079 llvm::MapVector<std::pair<IdentifierInfo *, unsigned /*isClassProperty*/>, 1080 ObjCPropertyDecl *>; 1081 using ProtocolPropertySet = llvm::SmallDenseSet<const ObjCProtocolDecl *, 8>; 1082 using PropertyDeclOrder = llvm::SmallVector<ObjCPropertyDecl *, 8>; 1083 1084 /// This routine collects list of properties to be implemented in the class. 1085 /// This includes, class's and its conforming protocols' properties. 1086 /// Note, the superclass's properties are not included in the list. 1087 virtual void collectPropertiesToImplement(PropertyMap &PM) const {} 1088 1089 SourceLocation getAtStartLoc() const { return ObjCContainerDeclBits.AtStart; } 1090 1091 void setAtStartLoc(SourceLocation Loc) { 1092 ObjCContainerDeclBits.AtStart = Loc; 1093 } 1094 1095 // Marks the end of the container. 1096 SourceRange getAtEndRange() const { return AtEnd; } 1097 1098 void setAtEndRange(SourceRange atEnd) { AtEnd = atEnd; } 1099 1100 SourceRange getSourceRange() const override LLVM_READONLY { 1101 return SourceRange(getAtStartLoc(), getAtEndRange().getEnd()); 1102 } 1103 1104 // Implement isa/cast/dyncast/etc. 1105 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 1106 1107 static bool classofKind(Kind K) { 1108 return K >= firstObjCContainer && 1109 K <= lastObjCContainer; 1110 } 1111 1112 static DeclContext *castToDeclContext(const ObjCContainerDecl *D) { 1113 return static_cast<DeclContext *>(const_cast<ObjCContainerDecl*>(D)); 1114 } 1115 1116 static ObjCContainerDecl *castFromDeclContext(const DeclContext *DC) { 1117 return static_cast<ObjCContainerDecl *>(const_cast<DeclContext*>(DC)); 1118 } 1119 }; 1120 1121 /// Represents an ObjC class declaration. 1122 /// 1123 /// For example: 1124 /// 1125 /// \code 1126 /// // MostPrimitive declares no super class (not particularly useful). 1127 /// \@interface MostPrimitive 1128 /// // no instance variables or methods. 1129 /// \@end 1130 /// 1131 /// // NSResponder inherits from NSObject & implements NSCoding (a protocol). 1132 /// \@interface NSResponder : NSObject \<NSCoding> 1133 /// { // instance variables are represented by ObjCIvarDecl. 1134 /// id nextResponder; // nextResponder instance variable. 1135 /// } 1136 /// - (NSResponder *)nextResponder; // return a pointer to NSResponder. 1137 /// - (void)mouseMoved:(NSEvent *)theEvent; // return void, takes a pointer 1138 /// \@end // to an NSEvent. 1139 /// \endcode 1140 /// 1141 /// Unlike C/C++, forward class declarations are accomplished with \@class. 1142 /// Unlike C/C++, \@class allows for a list of classes to be forward declared. 1143 /// Unlike C++, ObjC is a single-rooted class model. In Cocoa, classes 1144 /// typically inherit from NSObject (an exception is NSProxy). 1145 /// 1146 class ObjCInterfaceDecl : public ObjCContainerDecl 1147 , public Redeclarable<ObjCInterfaceDecl> { 1148 friend class ASTContext; 1149 friend class ODRDiagsEmitter; 1150 1151 /// TypeForDecl - This indicates the Type object that represents this 1152 /// TypeDecl. It is a cache maintained by ASTContext::getObjCInterfaceType 1153 mutable const Type *TypeForDecl = nullptr; 1154 1155 struct DefinitionData { 1156 /// The definition of this class, for quick access from any 1157 /// declaration. 1158 ObjCInterfaceDecl *Definition = nullptr; 1159 1160 /// When non-null, this is always an ObjCObjectType. 1161 TypeSourceInfo *SuperClassTInfo = nullptr; 1162 1163 /// Protocols referenced in the \@interface declaration 1164 ObjCProtocolList ReferencedProtocols; 1165 1166 /// Protocols reference in both the \@interface and class extensions. 1167 ObjCList<ObjCProtocolDecl> AllReferencedProtocols; 1168 1169 /// List of categories and class extensions defined for this class. 1170 /// 1171 /// Categories are stored as a linked list in the AST, since the categories 1172 /// and class extensions come long after the initial interface declaration, 1173 /// and we avoid dynamically-resized arrays in the AST wherever possible. 1174 ObjCCategoryDecl *CategoryList = nullptr; 1175 1176 /// IvarList - List of all ivars defined by this class; including class 1177 /// extensions and implementation. This list is built lazily. 1178 ObjCIvarDecl *IvarList = nullptr; 1179 1180 /// Indicates that the contents of this Objective-C class will be 1181 /// completed by the external AST source when required. 1182 mutable unsigned ExternallyCompleted : 1; 1183 1184 /// Indicates that the ivar cache does not yet include ivars 1185 /// declared in the implementation. 1186 mutable unsigned IvarListMissingImplementation : 1; 1187 1188 /// Indicates that this interface decl contains at least one initializer 1189 /// marked with the 'objc_designated_initializer' attribute. 1190 unsigned HasDesignatedInitializers : 1; 1191 1192 enum InheritedDesignatedInitializersState { 1193 /// We didn't calculate whether the designated initializers should be 1194 /// inherited or not. 1195 IDI_Unknown = 0, 1196 1197 /// Designated initializers are inherited for the super class. 1198 IDI_Inherited = 1, 1199 1200 /// The class does not inherit designated initializers. 1201 IDI_NotInherited = 2 1202 }; 1203 1204 /// One of the \c InheritedDesignatedInitializersState enumeratos. 1205 mutable unsigned InheritedDesignatedInitializers : 2; 1206 1207 /// Tracks whether a ODR hash has been computed for this interface. 1208 unsigned HasODRHash : 1; 1209 1210 /// A hash of parts of the class to help in ODR checking. 1211 unsigned ODRHash = 0; 1212 1213 /// The location of the last location in this declaration, before 1214 /// the properties/methods. For example, this will be the '>', '}', or 1215 /// identifier, 1216 SourceLocation EndLoc; 1217 1218 DefinitionData() 1219 : ExternallyCompleted(false), IvarListMissingImplementation(true), 1220 HasDesignatedInitializers(false), 1221 InheritedDesignatedInitializers(IDI_Unknown), HasODRHash(false) {} 1222 }; 1223 1224 /// The type parameters associated with this class, if any. 1225 ObjCTypeParamList *TypeParamList = nullptr; 1226 1227 /// Contains a pointer to the data associated with this class, 1228 /// which will be NULL if this class has not yet been defined. 1229 /// 1230 /// The bit indicates when we don't need to check for out-of-date 1231 /// declarations. It will be set unless modules are enabled. 1232 llvm::PointerIntPair<DefinitionData *, 1, bool> Data; 1233 1234 ObjCInterfaceDecl(const ASTContext &C, DeclContext *DC, SourceLocation AtLoc, 1235 IdentifierInfo *Id, ObjCTypeParamList *typeParamList, 1236 SourceLocation CLoc, ObjCInterfaceDecl *PrevDecl, 1237 bool IsInternal); 1238 1239 void anchor() override; 1240 1241 void LoadExternalDefinition() const; 1242 1243 DefinitionData &data() const { 1244 assert(Data.getPointer() && "Declaration has no definition!"); 1245 return *Data.getPointer(); 1246 } 1247 1248 /// Allocate the definition data for this class. 1249 void allocateDefinitionData(); 1250 1251 using redeclarable_base = Redeclarable<ObjCInterfaceDecl>; 1252 1253 ObjCInterfaceDecl *getNextRedeclarationImpl() override { 1254 return getNextRedeclaration(); 1255 } 1256 1257 ObjCInterfaceDecl *getPreviousDeclImpl() override { 1258 return getPreviousDecl(); 1259 } 1260 1261 ObjCInterfaceDecl *getMostRecentDeclImpl() override { 1262 return getMostRecentDecl(); 1263 } 1264 1265 public: 1266 static ObjCInterfaceDecl *Create(const ASTContext &C, DeclContext *DC, 1267 SourceLocation atLoc, 1268 IdentifierInfo *Id, 1269 ObjCTypeParamList *typeParamList, 1270 ObjCInterfaceDecl *PrevDecl, 1271 SourceLocation ClassLoc = SourceLocation(), 1272 bool isInternal = false); 1273 1274 static ObjCInterfaceDecl *CreateDeserialized(const ASTContext &C, unsigned ID); 1275 1276 /// Retrieve the type parameters of this class. 1277 /// 1278 /// This function looks for a type parameter list for the given 1279 /// class; if the class has been declared (with \c \@class) but not 1280 /// defined (with \c \@interface), it will search for a declaration that 1281 /// has type parameters, skipping any declarations that do not. 1282 ObjCTypeParamList *getTypeParamList() const; 1283 1284 /// Set the type parameters of this class. 1285 /// 1286 /// This function is used by the AST importer, which must import the type 1287 /// parameters after creating their DeclContext to avoid loops. 1288 void setTypeParamList(ObjCTypeParamList *TPL); 1289 1290 /// Retrieve the type parameters written on this particular declaration of 1291 /// the class. 1292 ObjCTypeParamList *getTypeParamListAsWritten() const { 1293 return TypeParamList; 1294 } 1295 1296 SourceRange getSourceRange() const override LLVM_READONLY { 1297 if (isThisDeclarationADefinition()) 1298 return ObjCContainerDecl::getSourceRange(); 1299 1300 return SourceRange(getAtStartLoc(), getLocation()); 1301 } 1302 1303 /// Indicate that this Objective-C class is complete, but that 1304 /// the external AST source will be responsible for filling in its contents 1305 /// when a complete class is required. 1306 void setExternallyCompleted(); 1307 1308 /// Indicate that this interface decl contains at least one initializer 1309 /// marked with the 'objc_designated_initializer' attribute. 1310 void setHasDesignatedInitializers(); 1311 1312 /// Returns true if this interface decl contains at least one initializer 1313 /// marked with the 'objc_designated_initializer' attribute. 1314 bool hasDesignatedInitializers() const; 1315 1316 /// Returns true if this interface decl declares a designated initializer 1317 /// or it inherites one from its super class. 1318 bool declaresOrInheritsDesignatedInitializers() const { 1319 return hasDesignatedInitializers() || inheritsDesignatedInitializers(); 1320 } 1321 1322 const ObjCProtocolList &getReferencedProtocols() const { 1323 assert(hasDefinition() && "Caller did not check for forward reference!"); 1324 if (data().ExternallyCompleted) 1325 LoadExternalDefinition(); 1326 1327 return data().ReferencedProtocols; 1328 } 1329 1330 ObjCImplementationDecl *getImplementation() const; 1331 void setImplementation(ObjCImplementationDecl *ImplD); 1332 1333 ObjCCategoryDecl *FindCategoryDeclaration(IdentifierInfo *CategoryId) const; 1334 1335 // Get the local instance/class method declared in a category. 1336 ObjCMethodDecl *getCategoryInstanceMethod(Selector Sel) const; 1337 ObjCMethodDecl *getCategoryClassMethod(Selector Sel) const; 1338 1339 ObjCMethodDecl *getCategoryMethod(Selector Sel, bool isInstance) const { 1340 return isInstance ? getCategoryInstanceMethod(Sel) 1341 : getCategoryClassMethod(Sel); 1342 } 1343 1344 using protocol_iterator = ObjCProtocolList::iterator; 1345 using protocol_range = llvm::iterator_range<protocol_iterator>; 1346 1347 protocol_range protocols() const { 1348 return protocol_range(protocol_begin(), protocol_end()); 1349 } 1350 1351 protocol_iterator protocol_begin() const { 1352 // FIXME: Should make sure no callers ever do this. 1353 if (!hasDefinition()) 1354 return protocol_iterator(); 1355 1356 if (data().ExternallyCompleted) 1357 LoadExternalDefinition(); 1358 1359 return data().ReferencedProtocols.begin(); 1360 } 1361 1362 protocol_iterator protocol_end() const { 1363 // FIXME: Should make sure no callers ever do this. 1364 if (!hasDefinition()) 1365 return protocol_iterator(); 1366 1367 if (data().ExternallyCompleted) 1368 LoadExternalDefinition(); 1369 1370 return data().ReferencedProtocols.end(); 1371 } 1372 1373 using protocol_loc_iterator = ObjCProtocolList::loc_iterator; 1374 using protocol_loc_range = llvm::iterator_range<protocol_loc_iterator>; 1375 1376 protocol_loc_range protocol_locs() const { 1377 return protocol_loc_range(protocol_loc_begin(), protocol_loc_end()); 1378 } 1379 1380 protocol_loc_iterator protocol_loc_begin() const { 1381 // FIXME: Should make sure no callers ever do this. 1382 if (!hasDefinition()) 1383 return protocol_loc_iterator(); 1384 1385 if (data().ExternallyCompleted) 1386 LoadExternalDefinition(); 1387 1388 return data().ReferencedProtocols.loc_begin(); 1389 } 1390 1391 protocol_loc_iterator protocol_loc_end() const { 1392 // FIXME: Should make sure no callers ever do this. 1393 if (!hasDefinition()) 1394 return protocol_loc_iterator(); 1395 1396 if (data().ExternallyCompleted) 1397 LoadExternalDefinition(); 1398 1399 return data().ReferencedProtocols.loc_end(); 1400 } 1401 1402 using all_protocol_iterator = ObjCList<ObjCProtocolDecl>::iterator; 1403 using all_protocol_range = llvm::iterator_range<all_protocol_iterator>; 1404 1405 all_protocol_range all_referenced_protocols() const { 1406 return all_protocol_range(all_referenced_protocol_begin(), 1407 all_referenced_protocol_end()); 1408 } 1409 1410 all_protocol_iterator all_referenced_protocol_begin() const { 1411 // FIXME: Should make sure no callers ever do this. 1412 if (!hasDefinition()) 1413 return all_protocol_iterator(); 1414 1415 if (data().ExternallyCompleted) 1416 LoadExternalDefinition(); 1417 1418 return data().AllReferencedProtocols.empty() 1419 ? protocol_begin() 1420 : data().AllReferencedProtocols.begin(); 1421 } 1422 1423 all_protocol_iterator all_referenced_protocol_end() const { 1424 // FIXME: Should make sure no callers ever do this. 1425 if (!hasDefinition()) 1426 return all_protocol_iterator(); 1427 1428 if (data().ExternallyCompleted) 1429 LoadExternalDefinition(); 1430 1431 return data().AllReferencedProtocols.empty() 1432 ? protocol_end() 1433 : data().AllReferencedProtocols.end(); 1434 } 1435 1436 using ivar_iterator = specific_decl_iterator<ObjCIvarDecl>; 1437 using ivar_range = llvm::iterator_range<specific_decl_iterator<ObjCIvarDecl>>; 1438 1439 ivar_range ivars() const { return ivar_range(ivar_begin(), ivar_end()); } 1440 1441 ivar_iterator ivar_begin() const { 1442 if (const ObjCInterfaceDecl *Def = getDefinition()) 1443 return ivar_iterator(Def->decls_begin()); 1444 1445 // FIXME: Should make sure no callers ever do this. 1446 return ivar_iterator(); 1447 } 1448 1449 ivar_iterator ivar_end() const { 1450 if (const ObjCInterfaceDecl *Def = getDefinition()) 1451 return ivar_iterator(Def->decls_end()); 1452 1453 // FIXME: Should make sure no callers ever do this. 1454 return ivar_iterator(); 1455 } 1456 1457 unsigned ivar_size() const { 1458 return std::distance(ivar_begin(), ivar_end()); 1459 } 1460 1461 bool ivar_empty() const { return ivar_begin() == ivar_end(); } 1462 1463 ObjCIvarDecl *all_declared_ivar_begin(); 1464 const ObjCIvarDecl *all_declared_ivar_begin() const { 1465 // Even though this modifies IvarList, it's conceptually const: 1466 // the ivar chain is essentially a cached property of ObjCInterfaceDecl. 1467 return const_cast<ObjCInterfaceDecl *>(this)->all_declared_ivar_begin(); 1468 } 1469 void setIvarList(ObjCIvarDecl *ivar) { data().IvarList = ivar; } 1470 1471 /// setProtocolList - Set the list of protocols that this interface 1472 /// implements. 1473 void setProtocolList(ObjCProtocolDecl *const* List, unsigned Num, 1474 const SourceLocation *Locs, ASTContext &C) { 1475 data().ReferencedProtocols.set(List, Num, Locs, C); 1476 } 1477 1478 /// mergeClassExtensionProtocolList - Merge class extension's protocol list 1479 /// into the protocol list for this class. 1480 void mergeClassExtensionProtocolList(ObjCProtocolDecl *const* List, 1481 unsigned Num, 1482 ASTContext &C); 1483 1484 /// Produce a name to be used for class's metadata. It comes either via 1485 /// objc_runtime_name attribute or class name. 1486 StringRef getObjCRuntimeNameAsString() const; 1487 1488 /// Returns the designated initializers for the interface. 1489 /// 1490 /// If this declaration does not have methods marked as designated 1491 /// initializers then the interface inherits the designated initializers of 1492 /// its super class. 1493 void getDesignatedInitializers( 1494 llvm::SmallVectorImpl<const ObjCMethodDecl *> &Methods) const; 1495 1496 /// Returns true if the given selector is a designated initializer for the 1497 /// interface. 1498 /// 1499 /// If this declaration does not have methods marked as designated 1500 /// initializers then the interface inherits the designated initializers of 1501 /// its super class. 1502 /// 1503 /// \param InitMethod if non-null and the function returns true, it receives 1504 /// the method that was marked as a designated initializer. 1505 bool 1506 isDesignatedInitializer(Selector Sel, 1507 const ObjCMethodDecl **InitMethod = nullptr) const; 1508 1509 /// Determine whether this particular declaration of this class is 1510 /// actually also a definition. 1511 bool isThisDeclarationADefinition() const { 1512 return getDefinition() == this; 1513 } 1514 1515 /// Determine whether this class has been defined. 1516 bool hasDefinition() const { 1517 // If the name of this class is out-of-date, bring it up-to-date, which 1518 // might bring in a definition. 1519 // Note: a null value indicates that we don't have a definition and that 1520 // modules are enabled. 1521 if (!Data.getOpaqueValue()) 1522 getMostRecentDecl(); 1523 1524 return Data.getPointer(); 1525 } 1526 1527 /// Retrieve the definition of this class, or NULL if this class 1528 /// has been forward-declared (with \@class) but not yet defined (with 1529 /// \@interface). 1530 ObjCInterfaceDecl *getDefinition() { 1531 return hasDefinition()? Data.getPointer()->Definition : nullptr; 1532 } 1533 1534 /// Retrieve the definition of this class, or NULL if this class 1535 /// has been forward-declared (with \@class) but not yet defined (with 1536 /// \@interface). 1537 const ObjCInterfaceDecl *getDefinition() const { 1538 return hasDefinition()? Data.getPointer()->Definition : nullptr; 1539 } 1540 1541 /// Starts the definition of this Objective-C class, taking it from 1542 /// a forward declaration (\@class) to a definition (\@interface). 1543 void startDefinition(); 1544 1545 /// Starts the definition without sharing it with other redeclarations. 1546 /// Such definition shouldn't be used for anything but only to compare if 1547 /// a duplicate is compatible with previous definition or if it is 1548 /// a distinct duplicate. 1549 void startDuplicateDefinitionForComparison(); 1550 void mergeDuplicateDefinitionWithCommon(const ObjCInterfaceDecl *Definition); 1551 1552 /// Retrieve the superclass type. 1553 const ObjCObjectType *getSuperClassType() const { 1554 if (TypeSourceInfo *TInfo = getSuperClassTInfo()) 1555 return TInfo->getType()->castAs<ObjCObjectType>(); 1556 1557 return nullptr; 1558 } 1559 1560 // Retrieve the type source information for the superclass. 1561 TypeSourceInfo *getSuperClassTInfo() const { 1562 // FIXME: Should make sure no callers ever do this. 1563 if (!hasDefinition()) 1564 return nullptr; 1565 1566 if (data().ExternallyCompleted) 1567 LoadExternalDefinition(); 1568 1569 return data().SuperClassTInfo; 1570 } 1571 1572 // Retrieve the declaration for the superclass of this class, which 1573 // does not include any type arguments that apply to the superclass. 1574 ObjCInterfaceDecl *getSuperClass() const; 1575 1576 void setSuperClass(TypeSourceInfo *superClass) { 1577 data().SuperClassTInfo = superClass; 1578 } 1579 1580 /// Iterator that walks over the list of categories, filtering out 1581 /// those that do not meet specific criteria. 1582 /// 1583 /// This class template is used for the various permutations of category 1584 /// and extension iterators. 1585 template<bool (*Filter)(ObjCCategoryDecl *)> 1586 class filtered_category_iterator { 1587 ObjCCategoryDecl *Current = nullptr; 1588 1589 void findAcceptableCategory(); 1590 1591 public: 1592 using value_type = ObjCCategoryDecl *; 1593 using reference = value_type; 1594 using pointer = value_type; 1595 using difference_type = std::ptrdiff_t; 1596 using iterator_category = std::input_iterator_tag; 1597 1598 filtered_category_iterator() = default; 1599 explicit filtered_category_iterator(ObjCCategoryDecl *Current) 1600 : Current(Current) { 1601 findAcceptableCategory(); 1602 } 1603 1604 reference operator*() const { return Current; } 1605 pointer operator->() const { return Current; } 1606 1607 filtered_category_iterator &operator++(); 1608 1609 filtered_category_iterator operator++(int) { 1610 filtered_category_iterator Tmp = *this; 1611 ++(*this); 1612 return Tmp; 1613 } 1614 1615 friend bool operator==(filtered_category_iterator X, 1616 filtered_category_iterator Y) { 1617 return X.Current == Y.Current; 1618 } 1619 1620 friend bool operator!=(filtered_category_iterator X, 1621 filtered_category_iterator Y) { 1622 return X.Current != Y.Current; 1623 } 1624 }; 1625 1626 private: 1627 /// Test whether the given category is visible. 1628 /// 1629 /// Used in the \c visible_categories_iterator. 1630 static bool isVisibleCategory(ObjCCategoryDecl *Cat); 1631 1632 public: 1633 /// Iterator that walks over the list of categories and extensions 1634 /// that are visible, i.e., not hidden in a non-imported submodule. 1635 using visible_categories_iterator = 1636 filtered_category_iterator<isVisibleCategory>; 1637 1638 using visible_categories_range = 1639 llvm::iterator_range<visible_categories_iterator>; 1640 1641 visible_categories_range visible_categories() const { 1642 return visible_categories_range(visible_categories_begin(), 1643 visible_categories_end()); 1644 } 1645 1646 /// Retrieve an iterator to the beginning of the visible-categories 1647 /// list. 1648 visible_categories_iterator visible_categories_begin() const { 1649 return visible_categories_iterator(getCategoryListRaw()); 1650 } 1651 1652 /// Retrieve an iterator to the end of the visible-categories list. 1653 visible_categories_iterator visible_categories_end() const { 1654 return visible_categories_iterator(); 1655 } 1656 1657 /// Determine whether the visible-categories list is empty. 1658 bool visible_categories_empty() const { 1659 return visible_categories_begin() == visible_categories_end(); 1660 } 1661 1662 private: 1663 /// Test whether the given category... is a category. 1664 /// 1665 /// Used in the \c known_categories_iterator. 1666 static bool isKnownCategory(ObjCCategoryDecl *) { return true; } 1667 1668 public: 1669 /// Iterator that walks over all of the known categories and 1670 /// extensions, including those that are hidden. 1671 using known_categories_iterator = filtered_category_iterator<isKnownCategory>; 1672 using known_categories_range = 1673 llvm::iterator_range<known_categories_iterator>; 1674 1675 known_categories_range known_categories() const { 1676 return known_categories_range(known_categories_begin(), 1677 known_categories_end()); 1678 } 1679 1680 /// Retrieve an iterator to the beginning of the known-categories 1681 /// list. 1682 known_categories_iterator known_categories_begin() const { 1683 return known_categories_iterator(getCategoryListRaw()); 1684 } 1685 1686 /// Retrieve an iterator to the end of the known-categories list. 1687 known_categories_iterator known_categories_end() const { 1688 return known_categories_iterator(); 1689 } 1690 1691 /// Determine whether the known-categories list is empty. 1692 bool known_categories_empty() const { 1693 return known_categories_begin() == known_categories_end(); 1694 } 1695 1696 private: 1697 /// Test whether the given category is a visible extension. 1698 /// 1699 /// Used in the \c visible_extensions_iterator. 1700 static bool isVisibleExtension(ObjCCategoryDecl *Cat); 1701 1702 public: 1703 /// Iterator that walks over all of the visible extensions, skipping 1704 /// any that are known but hidden. 1705 using visible_extensions_iterator = 1706 filtered_category_iterator<isVisibleExtension>; 1707 1708 using visible_extensions_range = 1709 llvm::iterator_range<visible_extensions_iterator>; 1710 1711 visible_extensions_range visible_extensions() const { 1712 return visible_extensions_range(visible_extensions_begin(), 1713 visible_extensions_end()); 1714 } 1715 1716 /// Retrieve an iterator to the beginning of the visible-extensions 1717 /// list. 1718 visible_extensions_iterator visible_extensions_begin() const { 1719 return visible_extensions_iterator(getCategoryListRaw()); 1720 } 1721 1722 /// Retrieve an iterator to the end of the visible-extensions list. 1723 visible_extensions_iterator visible_extensions_end() const { 1724 return visible_extensions_iterator(); 1725 } 1726 1727 /// Determine whether the visible-extensions list is empty. 1728 bool visible_extensions_empty() const { 1729 return visible_extensions_begin() == visible_extensions_end(); 1730 } 1731 1732 private: 1733 /// Test whether the given category is an extension. 1734 /// 1735 /// Used in the \c known_extensions_iterator. 1736 static bool isKnownExtension(ObjCCategoryDecl *Cat); 1737 1738 public: 1739 friend class ASTDeclReader; 1740 friend class ASTDeclWriter; 1741 friend class ASTReader; 1742 1743 /// Iterator that walks over all of the known extensions. 1744 using known_extensions_iterator = 1745 filtered_category_iterator<isKnownExtension>; 1746 using known_extensions_range = 1747 llvm::iterator_range<known_extensions_iterator>; 1748 1749 known_extensions_range known_extensions() const { 1750 return known_extensions_range(known_extensions_begin(), 1751 known_extensions_end()); 1752 } 1753 1754 /// Retrieve an iterator to the beginning of the known-extensions 1755 /// list. 1756 known_extensions_iterator known_extensions_begin() const { 1757 return known_extensions_iterator(getCategoryListRaw()); 1758 } 1759 1760 /// Retrieve an iterator to the end of the known-extensions list. 1761 known_extensions_iterator known_extensions_end() const { 1762 return known_extensions_iterator(); 1763 } 1764 1765 /// Determine whether the known-extensions list is empty. 1766 bool known_extensions_empty() const { 1767 return known_extensions_begin() == known_extensions_end(); 1768 } 1769 1770 /// Retrieve the raw pointer to the start of the category/extension 1771 /// list. 1772 ObjCCategoryDecl* getCategoryListRaw() const { 1773 // FIXME: Should make sure no callers ever do this. 1774 if (!hasDefinition()) 1775 return nullptr; 1776 1777 if (data().ExternallyCompleted) 1778 LoadExternalDefinition(); 1779 1780 return data().CategoryList; 1781 } 1782 1783 /// Set the raw pointer to the start of the category/extension 1784 /// list. 1785 void setCategoryListRaw(ObjCCategoryDecl *category) { 1786 data().CategoryList = category; 1787 } 1788 1789 ObjCPropertyDecl 1790 *FindPropertyVisibleInPrimaryClass(IdentifierInfo *PropertyId, 1791 ObjCPropertyQueryKind QueryKind) const; 1792 1793 void collectPropertiesToImplement(PropertyMap &PM) const override; 1794 1795 /// isSuperClassOf - Return true if this class is the specified class or is a 1796 /// super class of the specified interface class. 1797 bool isSuperClassOf(const ObjCInterfaceDecl *I) const { 1798 // If RHS is derived from LHS it is OK; else it is not OK. 1799 while (I != nullptr) { 1800 if (declaresSameEntity(this, I)) 1801 return true; 1802 1803 I = I->getSuperClass(); 1804 } 1805 return false; 1806 } 1807 1808 /// isArcWeakrefUnavailable - Checks for a class or one of its super classes 1809 /// to be incompatible with __weak references. Returns true if it is. 1810 bool isArcWeakrefUnavailable() const; 1811 1812 /// isObjCRequiresPropertyDefs - Checks that a class or one of its super 1813 /// classes must not be auto-synthesized. Returns class decl. if it must not 1814 /// be; 0, otherwise. 1815 const ObjCInterfaceDecl *isObjCRequiresPropertyDefs() const; 1816 1817 ObjCIvarDecl *lookupInstanceVariable(IdentifierInfo *IVarName, 1818 ObjCInterfaceDecl *&ClassDeclared); 1819 ObjCIvarDecl *lookupInstanceVariable(IdentifierInfo *IVarName) { 1820 ObjCInterfaceDecl *ClassDeclared; 1821 return lookupInstanceVariable(IVarName, ClassDeclared); 1822 } 1823 1824 ObjCProtocolDecl *lookupNestedProtocol(IdentifierInfo *Name); 1825 1826 // Lookup a method. First, we search locally. If a method isn't 1827 // found, we search referenced protocols and class categories. 1828 ObjCMethodDecl *lookupMethod(Selector Sel, bool isInstance, 1829 bool shallowCategoryLookup = false, 1830 bool followSuper = true, 1831 const ObjCCategoryDecl *C = nullptr) const; 1832 1833 /// Lookup an instance method for a given selector. 1834 ObjCMethodDecl *lookupInstanceMethod(Selector Sel) const { 1835 return lookupMethod(Sel, true/*isInstance*/); 1836 } 1837 1838 /// Lookup a class method for a given selector. 1839 ObjCMethodDecl *lookupClassMethod(Selector Sel) const { 1840 return lookupMethod(Sel, false/*isInstance*/); 1841 } 1842 1843 ObjCInterfaceDecl *lookupInheritedClass(const IdentifierInfo *ICName); 1844 1845 /// Lookup a method in the classes implementation hierarchy. 1846 ObjCMethodDecl *lookupPrivateMethod(const Selector &Sel, 1847 bool Instance=true) const; 1848 1849 ObjCMethodDecl *lookupPrivateClassMethod(const Selector &Sel) { 1850 return lookupPrivateMethod(Sel, false); 1851 } 1852 1853 /// Lookup a setter or getter in the class hierarchy, 1854 /// including in all categories except for category passed 1855 /// as argument. 1856 ObjCMethodDecl *lookupPropertyAccessor(const Selector Sel, 1857 const ObjCCategoryDecl *Cat, 1858 bool IsClassProperty) const { 1859 return lookupMethod(Sel, !IsClassProperty/*isInstance*/, 1860 false/*shallowCategoryLookup*/, 1861 true /* followsSuper */, 1862 Cat); 1863 } 1864 1865 SourceLocation getEndOfDefinitionLoc() const { 1866 if (!hasDefinition()) 1867 return getLocation(); 1868 1869 return data().EndLoc; 1870 } 1871 1872 void setEndOfDefinitionLoc(SourceLocation LE) { data().EndLoc = LE; } 1873 1874 /// Retrieve the starting location of the superclass. 1875 SourceLocation getSuperClassLoc() const; 1876 1877 /// isImplicitInterfaceDecl - check that this is an implicitly declared 1878 /// ObjCInterfaceDecl node. This is for legacy objective-c \@implementation 1879 /// declaration without an \@interface declaration. 1880 bool isImplicitInterfaceDecl() const { 1881 return hasDefinition() ? data().Definition->isImplicit() : isImplicit(); 1882 } 1883 1884 /// ClassImplementsProtocol - Checks that 'lProto' protocol 1885 /// has been implemented in IDecl class, its super class or categories (if 1886 /// lookupCategory is true). 1887 bool ClassImplementsProtocol(ObjCProtocolDecl *lProto, 1888 bool lookupCategory, 1889 bool RHSIsQualifiedID = false); 1890 1891 using redecl_range = redeclarable_base::redecl_range; 1892 using redecl_iterator = redeclarable_base::redecl_iterator; 1893 1894 using redeclarable_base::redecls_begin; 1895 using redeclarable_base::redecls_end; 1896 using redeclarable_base::redecls; 1897 using redeclarable_base::getPreviousDecl; 1898 using redeclarable_base::getMostRecentDecl; 1899 using redeclarable_base::isFirstDecl; 1900 1901 /// Retrieves the canonical declaration of this Objective-C class. 1902 ObjCInterfaceDecl *getCanonicalDecl() override { return getFirstDecl(); } 1903 const ObjCInterfaceDecl *getCanonicalDecl() const { return getFirstDecl(); } 1904 1905 // Low-level accessor 1906 const Type *getTypeForDecl() const { return TypeForDecl; } 1907 void setTypeForDecl(const Type *TD) const { TypeForDecl = TD; } 1908 1909 /// Get precomputed ODRHash or add a new one. 1910 unsigned getODRHash(); 1911 1912 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 1913 static bool classofKind(Kind K) { return K == ObjCInterface; } 1914 1915 private: 1916 /// True if a valid hash is stored in ODRHash. 1917 bool hasODRHash() const; 1918 void setHasODRHash(bool HasHash); 1919 1920 const ObjCInterfaceDecl *findInterfaceWithDesignatedInitializers() const; 1921 bool inheritsDesignatedInitializers() const; 1922 }; 1923 1924 /// ObjCIvarDecl - Represents an ObjC instance variable. In general, ObjC 1925 /// instance variables are identical to C. The only exception is Objective-C 1926 /// supports C++ style access control. For example: 1927 /// 1928 /// \@interface IvarExample : NSObject 1929 /// { 1930 /// id defaultToProtected; 1931 /// \@public: 1932 /// id canBePublic; // same as C++. 1933 /// \@protected: 1934 /// id canBeProtected; // same as C++. 1935 /// \@package: 1936 /// id canBePackage; // framework visibility (not available in C++). 1937 /// } 1938 /// 1939 class ObjCIvarDecl : public FieldDecl { 1940 void anchor() override; 1941 1942 public: 1943 enum AccessControl { 1944 None, Private, Protected, Public, Package 1945 }; 1946 1947 private: 1948 ObjCIvarDecl(ObjCContainerDecl *DC, SourceLocation StartLoc, 1949 SourceLocation IdLoc, IdentifierInfo *Id, 1950 QualType T, TypeSourceInfo *TInfo, AccessControl ac, Expr *BW, 1951 bool synthesized) 1952 : FieldDecl(ObjCIvar, DC, StartLoc, IdLoc, Id, T, TInfo, BW, 1953 /*Mutable=*/false, /*HasInit=*/ICIS_NoInit), 1954 DeclAccess(ac), Synthesized(synthesized) {} 1955 1956 public: 1957 static ObjCIvarDecl *Create(ASTContext &C, ObjCContainerDecl *DC, 1958 SourceLocation StartLoc, SourceLocation IdLoc, 1959 IdentifierInfo *Id, QualType T, 1960 TypeSourceInfo *TInfo, 1961 AccessControl ac, Expr *BW = nullptr, 1962 bool synthesized=false); 1963 1964 static ObjCIvarDecl *CreateDeserialized(ASTContext &C, unsigned ID); 1965 1966 /// Return the class interface that this ivar is logically contained 1967 /// in; this is either the interface where the ivar was declared, or the 1968 /// interface the ivar is conceptually a part of in the case of synthesized 1969 /// ivars. 1970 ObjCInterfaceDecl *getContainingInterface(); 1971 const ObjCInterfaceDecl *getContainingInterface() const { 1972 return const_cast<ObjCIvarDecl *>(this)->getContainingInterface(); 1973 } 1974 1975 ObjCIvarDecl *getNextIvar() { return NextIvar; } 1976 const ObjCIvarDecl *getNextIvar() const { return NextIvar; } 1977 void setNextIvar(ObjCIvarDecl *ivar) { NextIvar = ivar; } 1978 1979 ObjCIvarDecl *getCanonicalDecl() override { 1980 return cast<ObjCIvarDecl>(FieldDecl::getCanonicalDecl()); 1981 } 1982 const ObjCIvarDecl *getCanonicalDecl() const { 1983 return const_cast<ObjCIvarDecl *>(this)->getCanonicalDecl(); 1984 } 1985 1986 void setAccessControl(AccessControl ac) { DeclAccess = ac; } 1987 1988 AccessControl getAccessControl() const { return AccessControl(DeclAccess); } 1989 1990 AccessControl getCanonicalAccessControl() const { 1991 return DeclAccess == None ? Protected : AccessControl(DeclAccess); 1992 } 1993 1994 void setSynthesize(bool synth) { Synthesized = synth; } 1995 bool getSynthesize() const { return Synthesized; } 1996 1997 /// Retrieve the type of this instance variable when viewed as a member of a 1998 /// specific object type. 1999 QualType getUsageType(QualType objectType) const; 2000 2001 // Implement isa/cast/dyncast/etc. 2002 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 2003 static bool classofKind(Kind K) { return K == ObjCIvar; } 2004 2005 private: 2006 /// NextIvar - Next Ivar in the list of ivars declared in class; class's 2007 /// extensions and class's implementation 2008 ObjCIvarDecl *NextIvar = nullptr; 2009 2010 // NOTE: VC++ treats enums as signed, avoid using the AccessControl enum 2011 unsigned DeclAccess : 3; 2012 unsigned Synthesized : 1; 2013 }; 2014 2015 /// Represents a field declaration created by an \@defs(...). 2016 class ObjCAtDefsFieldDecl : public FieldDecl { 2017 ObjCAtDefsFieldDecl(DeclContext *DC, SourceLocation StartLoc, 2018 SourceLocation IdLoc, IdentifierInfo *Id, 2019 QualType T, Expr *BW) 2020 : FieldDecl(ObjCAtDefsField, DC, StartLoc, IdLoc, Id, T, 2021 /*TInfo=*/nullptr, // FIXME: Do ObjCAtDefs have declarators ? 2022 BW, /*Mutable=*/false, /*HasInit=*/ICIS_NoInit) {} 2023 2024 void anchor() override; 2025 2026 public: 2027 static ObjCAtDefsFieldDecl *Create(ASTContext &C, DeclContext *DC, 2028 SourceLocation StartLoc, 2029 SourceLocation IdLoc, IdentifierInfo *Id, 2030 QualType T, Expr *BW); 2031 2032 static ObjCAtDefsFieldDecl *CreateDeserialized(ASTContext &C, unsigned ID); 2033 2034 // Implement isa/cast/dyncast/etc. 2035 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 2036 static bool classofKind(Kind K) { return K == ObjCAtDefsField; } 2037 }; 2038 2039 /// Represents an Objective-C protocol declaration. 2040 /// 2041 /// Objective-C protocols declare a pure abstract type (i.e., no instance 2042 /// variables are permitted). Protocols originally drew inspiration from 2043 /// C++ pure virtual functions (a C++ feature with nice semantics and lousy 2044 /// syntax:-). Here is an example: 2045 /// 2046 /// \code 2047 /// \@protocol NSDraggingInfo <refproto1, refproto2> 2048 /// - (NSWindow *)draggingDestinationWindow; 2049 /// - (NSImage *)draggedImage; 2050 /// \@end 2051 /// \endcode 2052 /// 2053 /// This says that NSDraggingInfo requires two methods and requires everything 2054 /// that the two "referenced protocols" 'refproto1' and 'refproto2' require as 2055 /// well. 2056 /// 2057 /// \code 2058 /// \@interface ImplementsNSDraggingInfo : NSObject \<NSDraggingInfo> 2059 /// \@end 2060 /// \endcode 2061 /// 2062 /// ObjC protocols inspired Java interfaces. Unlike Java, ObjC classes and 2063 /// protocols are in distinct namespaces. For example, Cocoa defines both 2064 /// an NSObject protocol and class (which isn't allowed in Java). As a result, 2065 /// protocols are referenced using angle brackets as follows: 2066 /// 2067 /// id \<NSDraggingInfo> anyObjectThatImplementsNSDraggingInfo; 2068 class ObjCProtocolDecl : public ObjCContainerDecl, 2069 public Redeclarable<ObjCProtocolDecl> { 2070 struct DefinitionData { 2071 // The declaration that defines this protocol. 2072 ObjCProtocolDecl *Definition; 2073 2074 /// Referenced protocols 2075 ObjCProtocolList ReferencedProtocols; 2076 2077 /// Tracks whether a ODR hash has been computed for this protocol. 2078 unsigned HasODRHash : 1; 2079 2080 /// A hash of parts of the class to help in ODR checking. 2081 unsigned ODRHash = 0; 2082 }; 2083 2084 /// Contains a pointer to the data associated with this class, 2085 /// which will be NULL if this class has not yet been defined. 2086 /// 2087 /// The bit indicates when we don't need to check for out-of-date 2088 /// declarations. It will be set unless modules are enabled. 2089 llvm::PointerIntPair<DefinitionData *, 1, bool> Data; 2090 2091 ObjCProtocolDecl(ASTContext &C, DeclContext *DC, IdentifierInfo *Id, 2092 SourceLocation nameLoc, SourceLocation atStartLoc, 2093 ObjCProtocolDecl *PrevDecl); 2094 2095 void anchor() override; 2096 2097 DefinitionData &data() const { 2098 assert(Data.getPointer() && "Objective-C protocol has no definition!"); 2099 return *Data.getPointer(); 2100 } 2101 2102 void allocateDefinitionData(); 2103 2104 using redeclarable_base = Redeclarable<ObjCProtocolDecl>; 2105 2106 ObjCProtocolDecl *getNextRedeclarationImpl() override { 2107 return getNextRedeclaration(); 2108 } 2109 2110 ObjCProtocolDecl *getPreviousDeclImpl() override { 2111 return getPreviousDecl(); 2112 } 2113 2114 ObjCProtocolDecl *getMostRecentDeclImpl() override { 2115 return getMostRecentDecl(); 2116 } 2117 2118 /// True if a valid hash is stored in ODRHash. 2119 bool hasODRHash() const; 2120 void setHasODRHash(bool HasHash); 2121 2122 public: 2123 friend class ASTDeclReader; 2124 friend class ASTDeclWriter; 2125 friend class ASTReader; 2126 friend class ODRDiagsEmitter; 2127 2128 static ObjCProtocolDecl *Create(ASTContext &C, DeclContext *DC, 2129 IdentifierInfo *Id, 2130 SourceLocation nameLoc, 2131 SourceLocation atStartLoc, 2132 ObjCProtocolDecl *PrevDecl); 2133 2134 static ObjCProtocolDecl *CreateDeserialized(ASTContext &C, unsigned ID); 2135 2136 const ObjCProtocolList &getReferencedProtocols() const { 2137 assert(hasDefinition() && "No definition available!"); 2138 return data().ReferencedProtocols; 2139 } 2140 2141 using protocol_iterator = ObjCProtocolList::iterator; 2142 using protocol_range = llvm::iterator_range<protocol_iterator>; 2143 2144 protocol_range protocols() const { 2145 return protocol_range(protocol_begin(), protocol_end()); 2146 } 2147 2148 protocol_iterator protocol_begin() const { 2149 if (!hasDefinition()) 2150 return protocol_iterator(); 2151 2152 return data().ReferencedProtocols.begin(); 2153 } 2154 2155 protocol_iterator protocol_end() const { 2156 if (!hasDefinition()) 2157 return protocol_iterator(); 2158 2159 return data().ReferencedProtocols.end(); 2160 } 2161 2162 using protocol_loc_iterator = ObjCProtocolList::loc_iterator; 2163 using protocol_loc_range = llvm::iterator_range<protocol_loc_iterator>; 2164 2165 protocol_loc_range protocol_locs() const { 2166 return protocol_loc_range(protocol_loc_begin(), protocol_loc_end()); 2167 } 2168 2169 protocol_loc_iterator protocol_loc_begin() const { 2170 if (!hasDefinition()) 2171 return protocol_loc_iterator(); 2172 2173 return data().ReferencedProtocols.loc_begin(); 2174 } 2175 2176 protocol_loc_iterator protocol_loc_end() const { 2177 if (!hasDefinition()) 2178 return protocol_loc_iterator(); 2179 2180 return data().ReferencedProtocols.loc_end(); 2181 } 2182 2183 unsigned protocol_size() const { 2184 if (!hasDefinition()) 2185 return 0; 2186 2187 return data().ReferencedProtocols.size(); 2188 } 2189 2190 /// setProtocolList - Set the list of protocols that this interface 2191 /// implements. 2192 void setProtocolList(ObjCProtocolDecl *const*List, unsigned Num, 2193 const SourceLocation *Locs, ASTContext &C) { 2194 assert(hasDefinition() && "Protocol is not defined"); 2195 data().ReferencedProtocols.set(List, Num, Locs, C); 2196 } 2197 2198 /// This is true iff the protocol is tagged with the 2199 /// `objc_non_runtime_protocol` attribute. 2200 bool isNonRuntimeProtocol() const; 2201 2202 /// Get the set of all protocols implied by this protocols inheritance 2203 /// hierarchy. 2204 void getImpliedProtocols(llvm::DenseSet<const ObjCProtocolDecl *> &IPs) const; 2205 2206 ObjCProtocolDecl *lookupProtocolNamed(IdentifierInfo *PName); 2207 2208 // Lookup a method. First, we search locally. If a method isn't 2209 // found, we search referenced protocols and class categories. 2210 ObjCMethodDecl *lookupMethod(Selector Sel, bool isInstance) const; 2211 2212 ObjCMethodDecl *lookupInstanceMethod(Selector Sel) const { 2213 return lookupMethod(Sel, true/*isInstance*/); 2214 } 2215 2216 ObjCMethodDecl *lookupClassMethod(Selector Sel) const { 2217 return lookupMethod(Sel, false/*isInstance*/); 2218 } 2219 2220 /// Determine whether this protocol has a definition. 2221 bool hasDefinition() const { 2222 // If the name of this protocol is out-of-date, bring it up-to-date, which 2223 // might bring in a definition. 2224 // Note: a null value indicates that we don't have a definition and that 2225 // modules are enabled. 2226 if (!Data.getOpaqueValue()) 2227 getMostRecentDecl(); 2228 2229 return Data.getPointer(); 2230 } 2231 2232 /// Retrieve the definition of this protocol, if any. 2233 ObjCProtocolDecl *getDefinition() { 2234 return hasDefinition()? Data.getPointer()->Definition : nullptr; 2235 } 2236 2237 /// Retrieve the definition of this protocol, if any. 2238 const ObjCProtocolDecl *getDefinition() const { 2239 return hasDefinition()? Data.getPointer()->Definition : nullptr; 2240 } 2241 2242 /// Determine whether this particular declaration is also the 2243 /// definition. 2244 bool isThisDeclarationADefinition() const { 2245 return getDefinition() == this; 2246 } 2247 2248 /// Starts the definition of this Objective-C protocol. 2249 void startDefinition(); 2250 2251 /// Starts the definition without sharing it with other redeclarations. 2252 /// Such definition shouldn't be used for anything but only to compare if 2253 /// a duplicate is compatible with previous definition or if it is 2254 /// a distinct duplicate. 2255 void startDuplicateDefinitionForComparison(); 2256 void mergeDuplicateDefinitionWithCommon(const ObjCProtocolDecl *Definition); 2257 2258 /// Produce a name to be used for protocol's metadata. It comes either via 2259 /// objc_runtime_name attribute or protocol name. 2260 StringRef getObjCRuntimeNameAsString() const; 2261 2262 SourceRange getSourceRange() const override LLVM_READONLY { 2263 if (isThisDeclarationADefinition()) 2264 return ObjCContainerDecl::getSourceRange(); 2265 2266 return SourceRange(getAtStartLoc(), getLocation()); 2267 } 2268 2269 using redecl_range = redeclarable_base::redecl_range; 2270 using redecl_iterator = redeclarable_base::redecl_iterator; 2271 2272 using redeclarable_base::redecls_begin; 2273 using redeclarable_base::redecls_end; 2274 using redeclarable_base::redecls; 2275 using redeclarable_base::getPreviousDecl; 2276 using redeclarable_base::getMostRecentDecl; 2277 using redeclarable_base::isFirstDecl; 2278 2279 /// Retrieves the canonical declaration of this Objective-C protocol. 2280 ObjCProtocolDecl *getCanonicalDecl() override { return getFirstDecl(); } 2281 const ObjCProtocolDecl *getCanonicalDecl() const { return getFirstDecl(); } 2282 2283 void collectPropertiesToImplement(PropertyMap &PM) const override; 2284 2285 void collectInheritedProtocolProperties(const ObjCPropertyDecl *Property, 2286 ProtocolPropertySet &PS, 2287 PropertyDeclOrder &PO) const; 2288 2289 /// Get precomputed ODRHash or add a new one. 2290 unsigned getODRHash(); 2291 2292 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 2293 static bool classofKind(Kind K) { return K == ObjCProtocol; } 2294 }; 2295 2296 /// ObjCCategoryDecl - Represents a category declaration. A category allows 2297 /// you to add methods to an existing class (without subclassing or modifying 2298 /// the original class interface or implementation:-). Categories don't allow 2299 /// you to add instance data. The following example adds "myMethod" to all 2300 /// NSView's within a process: 2301 /// 2302 /// \@interface NSView (MyViewMethods) 2303 /// - myMethod; 2304 /// \@end 2305 /// 2306 /// Categories also allow you to split the implementation of a class across 2307 /// several files (a feature more naturally supported in C++). 2308 /// 2309 /// Categories were originally inspired by dynamic languages such as Common 2310 /// Lisp and Smalltalk. More traditional class-based languages (C++, Java) 2311 /// don't support this level of dynamism, which is both powerful and dangerous. 2312 class ObjCCategoryDecl : public ObjCContainerDecl { 2313 /// Interface belonging to this category 2314 ObjCInterfaceDecl *ClassInterface; 2315 2316 /// The type parameters associated with this category, if any. 2317 ObjCTypeParamList *TypeParamList = nullptr; 2318 2319 /// referenced protocols in this category. 2320 ObjCProtocolList ReferencedProtocols; 2321 2322 /// Next category belonging to this class. 2323 /// FIXME: this should not be a singly-linked list. Move storage elsewhere. 2324 ObjCCategoryDecl *NextClassCategory = nullptr; 2325 2326 /// The location of the category name in this declaration. 2327 SourceLocation CategoryNameLoc; 2328 2329 /// class extension may have private ivars. 2330 SourceLocation IvarLBraceLoc; 2331 SourceLocation IvarRBraceLoc; 2332 2333 ObjCCategoryDecl(DeclContext *DC, SourceLocation AtLoc, 2334 SourceLocation ClassNameLoc, SourceLocation CategoryNameLoc, 2335 IdentifierInfo *Id, ObjCInterfaceDecl *IDecl, 2336 ObjCTypeParamList *typeParamList, 2337 SourceLocation IvarLBraceLoc = SourceLocation(), 2338 SourceLocation IvarRBraceLoc = SourceLocation()); 2339 2340 void anchor() override; 2341 2342 public: 2343 friend class ASTDeclReader; 2344 friend class ASTDeclWriter; 2345 2346 static ObjCCategoryDecl *Create(ASTContext &C, DeclContext *DC, 2347 SourceLocation AtLoc, 2348 SourceLocation ClassNameLoc, 2349 SourceLocation CategoryNameLoc, 2350 IdentifierInfo *Id, 2351 ObjCInterfaceDecl *IDecl, 2352 ObjCTypeParamList *typeParamList, 2353 SourceLocation IvarLBraceLoc=SourceLocation(), 2354 SourceLocation IvarRBraceLoc=SourceLocation()); 2355 static ObjCCategoryDecl *CreateDeserialized(ASTContext &C, unsigned ID); 2356 2357 ObjCInterfaceDecl *getClassInterface() { return ClassInterface; } 2358 const ObjCInterfaceDecl *getClassInterface() const { return ClassInterface; } 2359 2360 /// Retrieve the type parameter list associated with this category or 2361 /// extension. 2362 ObjCTypeParamList *getTypeParamList() const { return TypeParamList; } 2363 2364 /// Set the type parameters of this category. 2365 /// 2366 /// This function is used by the AST importer, which must import the type 2367 /// parameters after creating their DeclContext to avoid loops. 2368 void setTypeParamList(ObjCTypeParamList *TPL); 2369 2370 2371 ObjCCategoryImplDecl *getImplementation() const; 2372 void setImplementation(ObjCCategoryImplDecl *ImplD); 2373 2374 /// setProtocolList - Set the list of protocols that this interface 2375 /// implements. 2376 void setProtocolList(ObjCProtocolDecl *const*List, unsigned Num, 2377 const SourceLocation *Locs, ASTContext &C) { 2378 ReferencedProtocols.set(List, Num, Locs, C); 2379 } 2380 2381 const ObjCProtocolList &getReferencedProtocols() const { 2382 return ReferencedProtocols; 2383 } 2384 2385 using protocol_iterator = ObjCProtocolList::iterator; 2386 using protocol_range = llvm::iterator_range<protocol_iterator>; 2387 2388 protocol_range protocols() const { 2389 return protocol_range(protocol_begin(), protocol_end()); 2390 } 2391 2392 protocol_iterator protocol_begin() const { 2393 return ReferencedProtocols.begin(); 2394 } 2395 2396 protocol_iterator protocol_end() const { return ReferencedProtocols.end(); } 2397 unsigned protocol_size() const { return ReferencedProtocols.size(); } 2398 2399 using protocol_loc_iterator = ObjCProtocolList::loc_iterator; 2400 using protocol_loc_range = llvm::iterator_range<protocol_loc_iterator>; 2401 2402 protocol_loc_range protocol_locs() const { 2403 return protocol_loc_range(protocol_loc_begin(), protocol_loc_end()); 2404 } 2405 2406 protocol_loc_iterator protocol_loc_begin() const { 2407 return ReferencedProtocols.loc_begin(); 2408 } 2409 2410 protocol_loc_iterator protocol_loc_end() const { 2411 return ReferencedProtocols.loc_end(); 2412 } 2413 2414 ObjCCategoryDecl *getNextClassCategory() const { return NextClassCategory; } 2415 2416 /// Retrieve the pointer to the next stored category (or extension), 2417 /// which may be hidden. 2418 ObjCCategoryDecl *getNextClassCategoryRaw() const { 2419 return NextClassCategory; 2420 } 2421 2422 bool IsClassExtension() const { return getIdentifier() == nullptr; } 2423 2424 using ivar_iterator = specific_decl_iterator<ObjCIvarDecl>; 2425 using ivar_range = llvm::iterator_range<specific_decl_iterator<ObjCIvarDecl>>; 2426 2427 ivar_range ivars() const { return ivar_range(ivar_begin(), ivar_end()); } 2428 2429 ivar_iterator ivar_begin() const { 2430 return ivar_iterator(decls_begin()); 2431 } 2432 2433 ivar_iterator ivar_end() const { 2434 return ivar_iterator(decls_end()); 2435 } 2436 2437 unsigned ivar_size() const { 2438 return std::distance(ivar_begin(), ivar_end()); 2439 } 2440 2441 bool ivar_empty() const { 2442 return ivar_begin() == ivar_end(); 2443 } 2444 2445 SourceLocation getCategoryNameLoc() const { return CategoryNameLoc; } 2446 void setCategoryNameLoc(SourceLocation Loc) { CategoryNameLoc = Loc; } 2447 2448 void setIvarLBraceLoc(SourceLocation Loc) { IvarLBraceLoc = Loc; } 2449 SourceLocation getIvarLBraceLoc() const { return IvarLBraceLoc; } 2450 void setIvarRBraceLoc(SourceLocation Loc) { IvarRBraceLoc = Loc; } 2451 SourceLocation getIvarRBraceLoc() const { return IvarRBraceLoc; } 2452 2453 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 2454 static bool classofKind(Kind K) { return K == ObjCCategory; } 2455 }; 2456 2457 class ObjCImplDecl : public ObjCContainerDecl { 2458 /// Class interface for this class/category implementation 2459 ObjCInterfaceDecl *ClassInterface; 2460 2461 void anchor() override; 2462 2463 protected: 2464 ObjCImplDecl(Kind DK, DeclContext *DC, 2465 ObjCInterfaceDecl *classInterface, 2466 IdentifierInfo *Id, 2467 SourceLocation nameLoc, SourceLocation atStartLoc) 2468 : ObjCContainerDecl(DK, DC, Id, nameLoc, atStartLoc), 2469 ClassInterface(classInterface) {} 2470 2471 public: 2472 const ObjCInterfaceDecl *getClassInterface() const { return ClassInterface; } 2473 ObjCInterfaceDecl *getClassInterface() { return ClassInterface; } 2474 void setClassInterface(ObjCInterfaceDecl *IFace); 2475 2476 void addInstanceMethod(ObjCMethodDecl *method) { 2477 // FIXME: Context should be set correctly before we get here. 2478 method->setLexicalDeclContext(this); 2479 addDecl(method); 2480 } 2481 2482 void addClassMethod(ObjCMethodDecl *method) { 2483 // FIXME: Context should be set correctly before we get here. 2484 method->setLexicalDeclContext(this); 2485 addDecl(method); 2486 } 2487 2488 void addPropertyImplementation(ObjCPropertyImplDecl *property); 2489 2490 ObjCPropertyImplDecl *FindPropertyImplDecl(IdentifierInfo *propertyId, 2491 ObjCPropertyQueryKind queryKind) const; 2492 ObjCPropertyImplDecl *FindPropertyImplIvarDecl(IdentifierInfo *ivarId) const; 2493 2494 // Iterator access to properties. 2495 using propimpl_iterator = specific_decl_iterator<ObjCPropertyImplDecl>; 2496 using propimpl_range = 2497 llvm::iterator_range<specific_decl_iterator<ObjCPropertyImplDecl>>; 2498 2499 propimpl_range property_impls() const { 2500 return propimpl_range(propimpl_begin(), propimpl_end()); 2501 } 2502 2503 propimpl_iterator propimpl_begin() const { 2504 return propimpl_iterator(decls_begin()); 2505 } 2506 2507 propimpl_iterator propimpl_end() const { 2508 return propimpl_iterator(decls_end()); 2509 } 2510 2511 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 2512 2513 static bool classofKind(Kind K) { 2514 return K >= firstObjCImpl && K <= lastObjCImpl; 2515 } 2516 }; 2517 2518 /// ObjCCategoryImplDecl - An object of this class encapsulates a category 2519 /// \@implementation declaration. If a category class has declaration of a 2520 /// property, its implementation must be specified in the category's 2521 /// \@implementation declaration. Example: 2522 /// \@interface I \@end 2523 /// \@interface I(CATEGORY) 2524 /// \@property int p1, d1; 2525 /// \@end 2526 /// \@implementation I(CATEGORY) 2527 /// \@dynamic p1,d1; 2528 /// \@end 2529 /// 2530 /// ObjCCategoryImplDecl 2531 class ObjCCategoryImplDecl : public ObjCImplDecl { 2532 // Category name location 2533 SourceLocation CategoryNameLoc; 2534 2535 ObjCCategoryImplDecl(DeclContext *DC, IdentifierInfo *Id, 2536 ObjCInterfaceDecl *classInterface, 2537 SourceLocation nameLoc, SourceLocation atStartLoc, 2538 SourceLocation CategoryNameLoc) 2539 : ObjCImplDecl(ObjCCategoryImpl, DC, classInterface, Id, 2540 nameLoc, atStartLoc), 2541 CategoryNameLoc(CategoryNameLoc) {} 2542 2543 void anchor() override; 2544 2545 public: 2546 friend class ASTDeclReader; 2547 friend class ASTDeclWriter; 2548 2549 static ObjCCategoryImplDecl *Create(ASTContext &C, DeclContext *DC, 2550 IdentifierInfo *Id, 2551 ObjCInterfaceDecl *classInterface, 2552 SourceLocation nameLoc, 2553 SourceLocation atStartLoc, 2554 SourceLocation CategoryNameLoc); 2555 static ObjCCategoryImplDecl *CreateDeserialized(ASTContext &C, unsigned ID); 2556 2557 ObjCCategoryDecl *getCategoryDecl() const; 2558 2559 SourceLocation getCategoryNameLoc() const { return CategoryNameLoc; } 2560 2561 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 2562 static bool classofKind(Kind K) { return K == ObjCCategoryImpl;} 2563 }; 2564 2565 raw_ostream &operator<<(raw_ostream &OS, const ObjCCategoryImplDecl &CID); 2566 2567 /// ObjCImplementationDecl - Represents a class definition - this is where 2568 /// method definitions are specified. For example: 2569 /// 2570 /// @code 2571 /// \@implementation MyClass 2572 /// - (void)myMethod { /* do something */ } 2573 /// \@end 2574 /// @endcode 2575 /// 2576 /// In a non-fragile runtime, instance variables can appear in the class 2577 /// interface, class extensions (nameless categories), and in the implementation 2578 /// itself, as well as being synthesized as backing storage for properties. 2579 /// 2580 /// In a fragile runtime, instance variables are specified in the class 2581 /// interface, \em not in the implementation. Nevertheless (for legacy reasons), 2582 /// we allow instance variables to be specified in the implementation. When 2583 /// specified, they need to be \em identical to the interface. 2584 class ObjCImplementationDecl : public ObjCImplDecl { 2585 /// Implementation Class's super class. 2586 ObjCInterfaceDecl *SuperClass; 2587 SourceLocation SuperLoc; 2588 2589 /// \@implementation may have private ivars. 2590 SourceLocation IvarLBraceLoc; 2591 SourceLocation IvarRBraceLoc; 2592 2593 /// Support for ivar initialization. 2594 /// The arguments used to initialize the ivars 2595 LazyCXXCtorInitializersPtr IvarInitializers; 2596 unsigned NumIvarInitializers = 0; 2597 2598 /// Do the ivars of this class require initialization other than 2599 /// zero-initialization? 2600 bool HasNonZeroConstructors : 1; 2601 2602 /// Do the ivars of this class require non-trivial destruction? 2603 bool HasDestructors : 1; 2604 2605 ObjCImplementationDecl(DeclContext *DC, 2606 ObjCInterfaceDecl *classInterface, 2607 ObjCInterfaceDecl *superDecl, 2608 SourceLocation nameLoc, SourceLocation atStartLoc, 2609 SourceLocation superLoc = SourceLocation(), 2610 SourceLocation IvarLBraceLoc=SourceLocation(), 2611 SourceLocation IvarRBraceLoc=SourceLocation()) 2612 : ObjCImplDecl(ObjCImplementation, DC, classInterface, 2613 classInterface ? classInterface->getIdentifier() 2614 : nullptr, 2615 nameLoc, atStartLoc), 2616 SuperClass(superDecl), SuperLoc(superLoc), 2617 IvarLBraceLoc(IvarLBraceLoc), IvarRBraceLoc(IvarRBraceLoc), 2618 HasNonZeroConstructors(false), HasDestructors(false) {} 2619 2620 void anchor() override; 2621 2622 public: 2623 friend class ASTDeclReader; 2624 friend class ASTDeclWriter; 2625 2626 static ObjCImplementationDecl *Create(ASTContext &C, DeclContext *DC, 2627 ObjCInterfaceDecl *classInterface, 2628 ObjCInterfaceDecl *superDecl, 2629 SourceLocation nameLoc, 2630 SourceLocation atStartLoc, 2631 SourceLocation superLoc = SourceLocation(), 2632 SourceLocation IvarLBraceLoc=SourceLocation(), 2633 SourceLocation IvarRBraceLoc=SourceLocation()); 2634 2635 static ObjCImplementationDecl *CreateDeserialized(ASTContext &C, unsigned ID); 2636 2637 /// init_iterator - Iterates through the ivar initializer list. 2638 using init_iterator = CXXCtorInitializer **; 2639 2640 /// init_const_iterator - Iterates through the ivar initializer list. 2641 using init_const_iterator = CXXCtorInitializer * const *; 2642 2643 using init_range = llvm::iterator_range<init_iterator>; 2644 using init_const_range = llvm::iterator_range<init_const_iterator>; 2645 2646 init_range inits() { return init_range(init_begin(), init_end()); } 2647 2648 init_const_range inits() const { 2649 return init_const_range(init_begin(), init_end()); 2650 } 2651 2652 /// init_begin() - Retrieve an iterator to the first initializer. 2653 init_iterator init_begin() { 2654 const auto *ConstThis = this; 2655 return const_cast<init_iterator>(ConstThis->init_begin()); 2656 } 2657 2658 /// begin() - Retrieve an iterator to the first initializer. 2659 init_const_iterator init_begin() const; 2660 2661 /// init_end() - Retrieve an iterator past the last initializer. 2662 init_iterator init_end() { 2663 return init_begin() + NumIvarInitializers; 2664 } 2665 2666 /// end() - Retrieve an iterator past the last initializer. 2667 init_const_iterator init_end() const { 2668 return init_begin() + NumIvarInitializers; 2669 } 2670 2671 /// getNumArgs - Number of ivars which must be initialized. 2672 unsigned getNumIvarInitializers() const { 2673 return NumIvarInitializers; 2674 } 2675 2676 void setNumIvarInitializers(unsigned numNumIvarInitializers) { 2677 NumIvarInitializers = numNumIvarInitializers; 2678 } 2679 2680 void setIvarInitializers(ASTContext &C, 2681 CXXCtorInitializer ** initializers, 2682 unsigned numInitializers); 2683 2684 /// Do any of the ivars of this class (not counting its base classes) 2685 /// require construction other than zero-initialization? 2686 bool hasNonZeroConstructors() const { return HasNonZeroConstructors; } 2687 void setHasNonZeroConstructors(bool val) { HasNonZeroConstructors = val; } 2688 2689 /// Do any of the ivars of this class (not counting its base classes) 2690 /// require non-trivial destruction? 2691 bool hasDestructors() const { return HasDestructors; } 2692 void setHasDestructors(bool val) { HasDestructors = val; } 2693 2694 /// getIdentifier - Get the identifier that names the class 2695 /// interface associated with this implementation. 2696 IdentifierInfo *getIdentifier() const { 2697 return getClassInterface()->getIdentifier(); 2698 } 2699 2700 /// getName - Get the name of identifier for the class interface associated 2701 /// with this implementation as a StringRef. 2702 // 2703 // FIXME: This is a bad API, we are hiding NamedDecl::getName with a different 2704 // meaning. 2705 StringRef getName() const { 2706 assert(getIdentifier() && "Name is not a simple identifier"); 2707 return getIdentifier()->getName(); 2708 } 2709 2710 /// Get the name of the class associated with this interface. 2711 // 2712 // FIXME: Move to StringRef API. 2713 std::string getNameAsString() const { return std::string(getName()); } 2714 2715 /// Produce a name to be used for class's metadata. It comes either via 2716 /// class's objc_runtime_name attribute or class name. 2717 StringRef getObjCRuntimeNameAsString() const; 2718 2719 const ObjCInterfaceDecl *getSuperClass() const { return SuperClass; } 2720 ObjCInterfaceDecl *getSuperClass() { return SuperClass; } 2721 SourceLocation getSuperClassLoc() const { return SuperLoc; } 2722 2723 void setSuperClass(ObjCInterfaceDecl * superCls) { SuperClass = superCls; } 2724 2725 void setIvarLBraceLoc(SourceLocation Loc) { IvarLBraceLoc = Loc; } 2726 SourceLocation getIvarLBraceLoc() const { return IvarLBraceLoc; } 2727 void setIvarRBraceLoc(SourceLocation Loc) { IvarRBraceLoc = Loc; } 2728 SourceLocation getIvarRBraceLoc() const { return IvarRBraceLoc; } 2729 2730 using ivar_iterator = specific_decl_iterator<ObjCIvarDecl>; 2731 using ivar_range = llvm::iterator_range<specific_decl_iterator<ObjCIvarDecl>>; 2732 2733 ivar_range ivars() const { return ivar_range(ivar_begin(), ivar_end()); } 2734 2735 ivar_iterator ivar_begin() const { 2736 return ivar_iterator(decls_begin()); 2737 } 2738 2739 ivar_iterator ivar_end() const { 2740 return ivar_iterator(decls_end()); 2741 } 2742 2743 unsigned ivar_size() const { 2744 return std::distance(ivar_begin(), ivar_end()); 2745 } 2746 2747 bool ivar_empty() const { 2748 return ivar_begin() == ivar_end(); 2749 } 2750 2751 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 2752 static bool classofKind(Kind K) { return K == ObjCImplementation; } 2753 }; 2754 2755 raw_ostream &operator<<(raw_ostream &OS, const ObjCImplementationDecl &ID); 2756 2757 /// ObjCCompatibleAliasDecl - Represents alias of a class. This alias is 2758 /// declared as \@compatibility_alias alias class. 2759 class ObjCCompatibleAliasDecl : public NamedDecl { 2760 /// Class that this is an alias of. 2761 ObjCInterfaceDecl *AliasedClass; 2762 2763 ObjCCompatibleAliasDecl(DeclContext *DC, SourceLocation L, IdentifierInfo *Id, 2764 ObjCInterfaceDecl* aliasedClass) 2765 : NamedDecl(ObjCCompatibleAlias, DC, L, Id), AliasedClass(aliasedClass) {} 2766 2767 void anchor() override; 2768 2769 public: 2770 static ObjCCompatibleAliasDecl *Create(ASTContext &C, DeclContext *DC, 2771 SourceLocation L, IdentifierInfo *Id, 2772 ObjCInterfaceDecl* aliasedClass); 2773 2774 static ObjCCompatibleAliasDecl *CreateDeserialized(ASTContext &C, 2775 unsigned ID); 2776 2777 const ObjCInterfaceDecl *getClassInterface() const { return AliasedClass; } 2778 ObjCInterfaceDecl *getClassInterface() { return AliasedClass; } 2779 void setClassInterface(ObjCInterfaceDecl *D) { AliasedClass = D; } 2780 2781 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 2782 static bool classofKind(Kind K) { return K == ObjCCompatibleAlias; } 2783 }; 2784 2785 /// ObjCPropertyImplDecl - Represents implementation declaration of a property 2786 /// in a class or category implementation block. For example: 2787 /// \@synthesize prop1 = ivar1; 2788 /// 2789 class ObjCPropertyImplDecl : public Decl { 2790 public: 2791 enum Kind { 2792 Synthesize, 2793 Dynamic 2794 }; 2795 2796 private: 2797 SourceLocation AtLoc; // location of \@synthesize or \@dynamic 2798 2799 /// For \@synthesize, the location of the ivar, if it was written in 2800 /// the source code. 2801 /// 2802 /// \code 2803 /// \@synthesize int a = b 2804 /// \endcode 2805 SourceLocation IvarLoc; 2806 2807 /// Property declaration being implemented 2808 ObjCPropertyDecl *PropertyDecl; 2809 2810 /// Null for \@dynamic. Required for \@synthesize. 2811 ObjCIvarDecl *PropertyIvarDecl; 2812 2813 /// The getter's definition, which has an empty body if synthesized. 2814 ObjCMethodDecl *GetterMethodDecl = nullptr; 2815 /// The getter's definition, which has an empty body if synthesized. 2816 ObjCMethodDecl *SetterMethodDecl = nullptr; 2817 2818 /// Null for \@dynamic. Non-null if property must be copy-constructed in 2819 /// getter. 2820 Expr *GetterCXXConstructor = nullptr; 2821 2822 /// Null for \@dynamic. Non-null if property has assignment operator to call 2823 /// in Setter synthesis. 2824 Expr *SetterCXXAssignment = nullptr; 2825 2826 ObjCPropertyImplDecl(DeclContext *DC, SourceLocation atLoc, SourceLocation L, 2827 ObjCPropertyDecl *property, 2828 Kind PK, 2829 ObjCIvarDecl *ivarDecl, 2830 SourceLocation ivarLoc) 2831 : Decl(ObjCPropertyImpl, DC, L), AtLoc(atLoc), 2832 IvarLoc(ivarLoc), PropertyDecl(property), PropertyIvarDecl(ivarDecl) { 2833 assert(PK == Dynamic || PropertyIvarDecl); 2834 } 2835 2836 public: 2837 friend class ASTDeclReader; 2838 2839 static ObjCPropertyImplDecl *Create(ASTContext &C, DeclContext *DC, 2840 SourceLocation atLoc, SourceLocation L, 2841 ObjCPropertyDecl *property, 2842 Kind PK, 2843 ObjCIvarDecl *ivarDecl, 2844 SourceLocation ivarLoc); 2845 2846 static ObjCPropertyImplDecl *CreateDeserialized(ASTContext &C, unsigned ID); 2847 2848 SourceRange getSourceRange() const override LLVM_READONLY; 2849 2850 SourceLocation getBeginLoc() const LLVM_READONLY { return AtLoc; } 2851 void setAtLoc(SourceLocation Loc) { AtLoc = Loc; } 2852 2853 ObjCPropertyDecl *getPropertyDecl() const { 2854 return PropertyDecl; 2855 } 2856 void setPropertyDecl(ObjCPropertyDecl *Prop) { PropertyDecl = Prop; } 2857 2858 Kind getPropertyImplementation() const { 2859 return PropertyIvarDecl ? Synthesize : Dynamic; 2860 } 2861 2862 ObjCIvarDecl *getPropertyIvarDecl() const { 2863 return PropertyIvarDecl; 2864 } 2865 SourceLocation getPropertyIvarDeclLoc() const { return IvarLoc; } 2866 2867 void setPropertyIvarDecl(ObjCIvarDecl *Ivar, 2868 SourceLocation IvarLoc) { 2869 PropertyIvarDecl = Ivar; 2870 this->IvarLoc = IvarLoc; 2871 } 2872 2873 /// For \@synthesize, returns true if an ivar name was explicitly 2874 /// specified. 2875 /// 2876 /// \code 2877 /// \@synthesize int a = b; // true 2878 /// \@synthesize int a; // false 2879 /// \endcode 2880 bool isIvarNameSpecified() const { 2881 return IvarLoc.isValid() && IvarLoc != getLocation(); 2882 } 2883 2884 ObjCMethodDecl *getGetterMethodDecl() const { return GetterMethodDecl; } 2885 void setGetterMethodDecl(ObjCMethodDecl *MD) { GetterMethodDecl = MD; } 2886 2887 ObjCMethodDecl *getSetterMethodDecl() const { return SetterMethodDecl; } 2888 void setSetterMethodDecl(ObjCMethodDecl *MD) { SetterMethodDecl = MD; } 2889 2890 Expr *getGetterCXXConstructor() const { 2891 return GetterCXXConstructor; 2892 } 2893 2894 void setGetterCXXConstructor(Expr *getterCXXConstructor) { 2895 GetterCXXConstructor = getterCXXConstructor; 2896 } 2897 2898 Expr *getSetterCXXAssignment() const { 2899 return SetterCXXAssignment; 2900 } 2901 2902 void setSetterCXXAssignment(Expr *setterCXXAssignment) { 2903 SetterCXXAssignment = setterCXXAssignment; 2904 } 2905 2906 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 2907 static bool classofKind(Decl::Kind K) { return K == ObjCPropertyImpl; } 2908 }; 2909 2910 template<bool (*Filter)(ObjCCategoryDecl *)> 2911 void 2912 ObjCInterfaceDecl::filtered_category_iterator<Filter>:: 2913 findAcceptableCategory() { 2914 while (Current && !Filter(Current)) 2915 Current = Current->getNextClassCategoryRaw(); 2916 } 2917 2918 template<bool (*Filter)(ObjCCategoryDecl *)> 2919 inline ObjCInterfaceDecl::filtered_category_iterator<Filter> & 2920 ObjCInterfaceDecl::filtered_category_iterator<Filter>::operator++() { 2921 Current = Current->getNextClassCategoryRaw(); 2922 findAcceptableCategory(); 2923 return *this; 2924 } 2925 2926 inline bool ObjCInterfaceDecl::isVisibleCategory(ObjCCategoryDecl *Cat) { 2927 return !Cat->isInvalidDecl() && Cat->isUnconditionallyVisible(); 2928 } 2929 2930 inline bool ObjCInterfaceDecl::isVisibleExtension(ObjCCategoryDecl *Cat) { 2931 return !Cat->isInvalidDecl() && Cat->IsClassExtension() && 2932 Cat->isUnconditionallyVisible(); 2933 } 2934 2935 inline bool ObjCInterfaceDecl::isKnownExtension(ObjCCategoryDecl *Cat) { 2936 return !Cat->isInvalidDecl() && Cat->IsClassExtension(); 2937 } 2938 2939 } // namespace clang 2940 2941 #endif // LLVM_CLANG_AST_DECLOBJC_H 2942