contrib/llvm/tools/clang/include/clang/AST/DeclObjC.h

   1 //===--- DeclObjC.h - Classes for representing declarations -----*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file defines the DeclObjC interface and subclasses.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_AST_DECLOBJC_H
  15 #define LLVM_CLANG_AST_DECLOBJC_H
  16
  17 #include "clang/AST/Decl.h"
  18 #include "clang/AST/SelectorLocationsKind.h"
  19 #include "llvm/ADT/STLExtras.h"
  20 #include "llvm/Support/Compiler.h"
  21
  22 namespace clang {
  23 class Expr;
  24 class Stmt;
  25 class FunctionDecl;
  26 class RecordDecl;
  27 class ObjCIvarDecl;
  28 class ObjCMethodDecl;
  29 class ObjCProtocolDecl;
  30 class ObjCCategoryDecl;
  31 class ObjCPropertyDecl;
  32 class ObjCPropertyImplDecl;
  33 class CXXCtorInitializer;
  34
  35 class ObjCListBase {
  36   ObjCListBase(const ObjCListBase &) LLVM_DELETED_FUNCTION;
  37   void operator=(const ObjCListBase &) LLVM_DELETED_FUNCTION;
  38 protected:
  39   /// List is an array of pointers to objects that are not owned by this object.
  40   void **List;
  41   unsigned NumElts;
  42
  43 public:
  44   ObjCListBase() : List(0), NumElts(0) {}
  45   unsigned size() const { return NumElts; }
  46   bool empty() const { return NumElts == 0; }
  47
  48 protected:
  49   void set(void *const* InList, unsigned Elts, ASTContext &Ctx);
  50 };
  51
  52
  53 /// ObjCList - This is a simple template class used to hold various lists of
  54 /// decls etc, which is heavily used by the ObjC front-end.  This only use case
  55 /// this supports is setting the list all at once and then reading elements out
  56 /// of it.
  57 template <typename T>
  58 class ObjCList : public ObjCListBase {
  59 public:
  60   void set(T* const* InList, unsigned Elts, ASTContext &Ctx) {
  61     ObjCListBase::set(reinterpret_cast<void*const*>(InList), Elts, Ctx);
  62   }
  63
  64   typedef T* const * iterator;
  65   iterator begin() const { return (iterator)List; }
  66   iterator end() const { return (iterator)List+NumElts; }
  67
  68   T* operator[](unsigned Idx) const {
  69     assert(Idx < NumElts && "Invalid access");
  70     return (T*)List[Idx];
  71   }
  72 };
  73
  74 /// \brief A list of Objective-C protocols, along with the source
  75 /// locations at which they were referenced.
  76 class ObjCProtocolList : public ObjCList<ObjCProtocolDecl> {
  77   SourceLocation *Locations;
  78
  79   using ObjCList<ObjCProtocolDecl>::set;
  80
  81 public:
  82   ObjCProtocolList() : ObjCList<ObjCProtocolDecl>(), Locations(0) { }
  83
  84   typedef const SourceLocation *loc_iterator;
  85   loc_iterator loc_begin() const { return Locations; }
  86   loc_iterator loc_end() const { return Locations + size(); }
  87
  88   void set(ObjCProtocolDecl* const* InList, unsigned Elts,
  89            const SourceLocation *Locs, ASTContext &Ctx);
  90 };
  91
  92
  93 /// ObjCMethodDecl - Represents an instance or class method declaration.
  94 /// ObjC methods can be declared within 4 contexts: class interfaces,
  95 /// categories, protocols, and class implementations. While C++ member
  96 /// functions leverage C syntax, Objective-C method syntax is modeled after
  97 /// Smalltalk (using colons to specify argument types/expressions).
  98 /// Here are some brief examples:
  99 ///
 100 /// Setter/getter instance methods:
 101 /// - (void)setMenu:(NSMenu *)menu;
 102 /// - (NSMenu *)menu;
 103 ///
 104 /// Instance method that takes 2 NSView arguments:
 105 /// - (void)replaceSubview:(NSView *)oldView with:(NSView *)newView;
 106 ///
 107 /// Getter class method:
 108 /// + (NSMenu *)defaultMenu;
 109 ///
 110 /// A selector represents a unique name for a method. The selector names for
 111 /// the above methods are setMenu:, menu, replaceSubview:with:, and defaultMenu.
 112 ///
 113 class ObjCMethodDecl : public NamedDecl, public DeclContext {
 114 public:
 115   enum ImplementationControl { None, Required, Optional };
 116 private:
 117   // The conventional meaning of this method; an ObjCMethodFamily.
 118   // This is not serialized; instead, it is computed on demand and
 119   // cached.
 120   mutable unsigned Family : ObjCMethodFamilyBitWidth;
 121
 122   /// instance (true) or class (false) method.
 123   unsigned IsInstance : 1;
 124   unsigned IsVariadic : 1;
 125
 126   /// True if this method is the getter or setter for an explicit property.
 127   unsigned IsPropertyAccessor : 1;
 128
 129   // Method has a definition.
 130   unsigned IsDefined : 1;
 131
 132   /// \brief Method redeclaration in the same interface.
 133   unsigned IsRedeclaration : 1;
 134
 135   /// \brief Is redeclared in the same interface.
 136   mutable unsigned HasRedeclaration : 1;
 137
 138   // NOTE: VC++ treats enums as signed, avoid using ImplementationControl enum
 139   /// \@required/\@optional
 140   unsigned DeclImplementation : 2;
 141
 142   // NOTE: VC++ treats enums as signed, avoid using the ObjCDeclQualifier enum
 143   /// in, inout, etc.
 144   unsigned objcDeclQualifier : 6;
 145
 146   /// \brief Indicates whether this method has a related result type.
 147   unsigned RelatedResultType : 1;
 148
 149   /// \brief Whether the locations of the selector identifiers are in a
 150   /// "standard" position, a enum SelectorLocationsKind.
 151   unsigned SelLocsKind : 2;
 152
 153   /// \brief Whether this method overrides any other in the class hierarchy.
 154   ///
 155   /// A method is said to override any method in the class's
 156   /// base classes, its protocols, or its categories' protocols, that has
 157   /// the same selector and is of the same kind (class or instance).
 158   /// A method in an implementation is not considered as overriding the same
 159   /// method in the interface or its categories.
 160   unsigned IsOverriding : 1;
 161
 162   /// \brief Indicates if the method was a definition but its body was skipped.
 163   unsigned HasSkippedBody : 1;
 164
 165   // Result type of this method.
 166   QualType MethodDeclType;
 167
 168   // Type source information for the result type.
 169   TypeSourceInfo *ResultTInfo;
 170
 171   /// \brief Array of ParmVarDecls for the formal parameters of this method
 172   /// and optionally followed by selector locations.
 173   void *ParamsAndSelLocs;
 174   unsigned NumParams;
 175
 176   /// List of attributes for this method declaration.
 177   SourceLocation DeclEndLoc; // the location of the ';' or '{'.
 178
 179   // The following are only used for method definitions, null otherwise.
 180   LazyDeclStmtPtr Body;
 181
 182   /// SelfDecl - Decl for the implicit self parameter. This is lazily
 183   /// constructed by createImplicitParams.
 184   ImplicitParamDecl *SelfDecl;
 185   /// CmdDecl - Decl for the implicit _cmd parameter. This is lazily
 186   /// constructed by createImplicitParams.
 187   ImplicitParamDecl *CmdDecl;
 188
 189   SelectorLocationsKind getSelLocsKind() const {
 190     return (SelectorLocationsKind)SelLocsKind;
 191   }
 192   bool hasStandardSelLocs() const {
 193     return getSelLocsKind() != SelLoc_NonStandard;
 194   }
 195
 196   /// \brief Get a pointer to the stored selector identifiers locations array.
 197   /// No locations will be stored if HasStandardSelLocs is true.
 198   SourceLocation *getStoredSelLocs() {
 199     return reinterpret_cast<SourceLocation*>(getParams() + NumParams);
 200   }
 201   const SourceLocation *getStoredSelLocs() const {
 202     return reinterpret_cast<const SourceLocation*>(getParams() + NumParams);
 203   }
 204
 205   /// \brief Get a pointer to the stored selector identifiers locations array.
 206   /// No locations will be stored if HasStandardSelLocs is true.
 207   ParmVarDecl **getParams() {
 208     return reinterpret_cast<ParmVarDecl **>(ParamsAndSelLocs);
 209   }
 210   const ParmVarDecl *const *getParams() const {
 211     return reinterpret_cast<const ParmVarDecl *const *>(ParamsAndSelLocs);
 212   }
 213
 214   /// \brief Get the number of stored selector identifiers locations.
 215   /// No locations will be stored if HasStandardSelLocs is true.
 216   unsigned getNumStoredSelLocs() const {
 217     if (hasStandardSelLocs())
 218       return 0;
 219     return getNumSelectorLocs();
 220   }
 221
 222   void setParamsAndSelLocs(ASTContext &C,
 223                            ArrayRef<ParmVarDecl*> Params,
 224                            ArrayRef<SourceLocation> SelLocs);
 225
 226   ObjCMethodDecl(SourceLocation beginLoc, SourceLocation endLoc,
 227                  Selector SelInfo, QualType T,
 228                  TypeSourceInfo *ResultTInfo,
 229                  DeclContext *contextDecl,
 230                  bool isInstance = true,
 231                  bool isVariadic = false,
 232                  bool isPropertyAccessor = false,
 233                  bool isImplicitlyDeclared = false,
 234                  bool isDefined = false,
 235                  ImplementationControl impControl = None,
 236                  bool HasRelatedResultType = false)
 237   : NamedDecl(ObjCMethod, contextDecl, beginLoc, SelInfo),
 238     DeclContext(ObjCMethod), Family(InvalidObjCMethodFamily),
 239     IsInstance(isInstance), IsVariadic(isVariadic),
 240     IsPropertyAccessor(isPropertyAccessor),
 241     IsDefined(isDefined), IsRedeclaration(0), HasRedeclaration(0),
 242     DeclImplementation(impControl), objcDeclQualifier(OBJC_TQ_None),
 243     RelatedResultType(HasRelatedResultType),
 244     SelLocsKind(SelLoc_StandardNoSpace), IsOverriding(0), HasSkippedBody(0),
 245     MethodDeclType(T), ResultTInfo(ResultTInfo),
 246     ParamsAndSelLocs(0), NumParams(0),
 247     DeclEndLoc(endLoc), Body(), SelfDecl(0), CmdDecl(0) {
 248     setImplicit(isImplicitlyDeclared);
 249   }
 250
 251   /// \brief A definition will return its interface declaration.
 252   /// An interface declaration will return its definition.
 253   /// Otherwise it will return itself.
 254   virtual ObjCMethodDecl *getNextRedeclaration();
 255
 256 public:
 257   static ObjCMethodDecl *Create(ASTContext &C,
 258                                 SourceLocation beginLoc,
 259                                 SourceLocation endLoc,
 260                                 Selector SelInfo,
 261                                 QualType T,
 262                                 TypeSourceInfo *ResultTInfo,
 263                                 DeclContext *contextDecl,
 264                                 bool isInstance = true,
 265                                 bool isVariadic = false,
 266                                 bool isPropertyAccessor = false,
 267                                 bool isImplicitlyDeclared = false,
 268                                 bool isDefined = false,
 269                                 ImplementationControl impControl = None,
 270                                 bool HasRelatedResultType = false);
 271
 272   static ObjCMethodDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 273
 274   virtual ObjCMethodDecl *getCanonicalDecl();
 275   const ObjCMethodDecl *getCanonicalDecl() const {
 276     return const_cast<ObjCMethodDecl*>(this)->getCanonicalDecl();
 277   }
 278
 279   ObjCDeclQualifier getObjCDeclQualifier() const {
 280     return ObjCDeclQualifier(objcDeclQualifier);
 281   }
 282   void setObjCDeclQualifier(ObjCDeclQualifier QV) { objcDeclQualifier = QV; }
 283
 284   /// \brief Determine whether this method has a result type that is related
 285   /// to the message receiver's type.
 286   bool hasRelatedResultType() const { return RelatedResultType; }
 287
 288   /// \brief Note whether this method has a related result type.
 289   void SetRelatedResultType(bool RRT = true) { RelatedResultType = RRT; }
 290
 291   /// \brief True if this is a method redeclaration in the same interface.
 292   bool isRedeclaration() const { return IsRedeclaration; }
 293   void setAsRedeclaration(const ObjCMethodDecl *PrevMethod);
 294
 295   /// \brief Returns the location where the declarator ends. It will be
 296   /// the location of ';' for a method declaration and the location of '{'
 297   /// for a method definition.
 298   SourceLocation getDeclaratorEndLoc() const { return DeclEndLoc; }
 299
 300   // Location information, modeled after the Stmt API.
 301   SourceLocation getLocStart() const LLVM_READONLY { return getLocation(); }
 302   SourceLocation getLocEnd() const LLVM_READONLY;
 303   virtual SourceRange getSourceRange() const LLVM_READONLY {
 304     return SourceRange(getLocation(), getLocEnd());
 305   }
 306
 307   SourceLocation getSelectorStartLoc() const {
 308     if (isImplicit())
 309       return getLocStart();
 310     return getSelectorLoc(0);
 311   }
 312   SourceLocation getSelectorLoc(unsigned Index) const {
 313     assert(Index < getNumSelectorLocs() && "Index out of range!");
 314     if (hasStandardSelLocs())
 315       return getStandardSelectorLoc(Index, getSelector(),
 316                                    getSelLocsKind() == SelLoc_StandardWithSpace,
 317                       llvm::makeArrayRef(const_cast<ParmVarDecl**>(getParams()),
 318                                          NumParams),
 319                                    DeclEndLoc);
 320     return getStoredSelLocs()[Index];
 321   }
 322
 323   void getSelectorLocs(SmallVectorImpl<SourceLocation> &SelLocs) const;
 324
 325   unsigned getNumSelectorLocs() const {
 326     if (isImplicit())
 327       return 0;
 328     Selector Sel = getSelector();
 329     if (Sel.isUnarySelector())
 330       return 1;
 331     return Sel.getNumArgs();
 332   }
 333
 334   ObjCInterfaceDecl *getClassInterface();
 335   const ObjCInterfaceDecl *getClassInterface() const {
 336     return const_cast<ObjCMethodDecl*>(this)->getClassInterface();
 337   }
 338
 339   Selector getSelector() const { return getDeclName().getObjCSelector(); }
 340
 341   QualType getResultType() const { return MethodDeclType; }
 342   void setResultType(QualType T) { MethodDeclType = T; }
 343
 344   /// \brief Determine the type of an expression that sends a message to this
 345   /// function.
 346   QualType getSendResultType() const {
 347     return getResultType().getNonLValueExprType(getASTContext());
 348   }
 349
 350   TypeSourceInfo *getResultTypeSourceInfo() const { return ResultTInfo; }
 351   void setResultTypeSourceInfo(TypeSourceInfo *TInfo) { ResultTInfo = TInfo; }
 352
 353   // Iterator access to formal parameters.
 354   unsigned param_size() const { return NumParams; }
 355   typedef const ParmVarDecl *const *param_const_iterator;
 356   typedef ParmVarDecl *const *param_iterator;
 357   param_const_iterator param_begin() const { return getParams(); }
 358   param_const_iterator param_end() const { return getParams() + NumParams; }
 359   param_iterator param_begin() { return getParams(); }
 360   param_iterator param_end() { return getParams() + NumParams; }
 361   // This method returns and of the parameters which are part of the selector
 362   // name mangling requirements.
 363   param_const_iterator sel_param_end() const {
 364     return param_begin() + getSelector().getNumArgs();
 365   }
 366
 367   /// \brief Sets the method's parameters and selector source locations.
 368   /// If the method is implicit (not coming from source) \p SelLocs is
 369   /// ignored.
 370   void setMethodParams(ASTContext &C,
 371                        ArrayRef<ParmVarDecl*> Params,
 372                        ArrayRef<SourceLocation> SelLocs =
 373                            ArrayRef<SourceLocation>());
 374
 375   // Iterator access to parameter types.
 376   typedef std::const_mem_fun_t<QualType, ParmVarDecl> deref_fun;
 377   typedef llvm::mapped_iterator<param_const_iterator, deref_fun>
 378       arg_type_iterator;
 379
 380   arg_type_iterator arg_type_begin() const {
 381     return llvm::map_iterator(param_begin(), deref_fun(&ParmVarDecl::getType));
 382   }
 383   arg_type_iterator arg_type_end() const {
 384     return llvm::map_iterator(param_end(), deref_fun(&ParmVarDecl::getType));
 385   }
 386
 387   /// createImplicitParams - Used to lazily create the self and cmd
 388   /// implict parameters. This must be called prior to using getSelfDecl()
 389   /// or getCmdDecl(). The call is ignored if the implicit paramters
 390   /// have already been created.
 391   void createImplicitParams(ASTContext &Context, const ObjCInterfaceDecl *ID);
 392
 393   ImplicitParamDecl * getSelfDecl() const { return SelfDecl; }
 394   void setSelfDecl(ImplicitParamDecl *SD) { SelfDecl = SD; }
 395   ImplicitParamDecl * getCmdDecl() const { return CmdDecl; }
 396   void setCmdDecl(ImplicitParamDecl *CD) { CmdDecl = CD; }
 397
 398   /// Determines the family of this method.
 399   ObjCMethodFamily getMethodFamily() const;
 400
 401   bool isInstanceMethod() const { return IsInstance; }
 402   void setInstanceMethod(bool isInst) { IsInstance = isInst; }
 403   bool isVariadic() const { return IsVariadic; }
 404   void setVariadic(bool isVar) { IsVariadic = isVar; }
 405
 406   bool isClassMethod() const { return !IsInstance; }
 407
 408   bool isPropertyAccessor() const { return IsPropertyAccessor; }
 409   void setPropertyAccessor(bool isAccessor) { IsPropertyAccessor = isAccessor; }
 410
 411   bool isDefined() const { return IsDefined; }
 412   void setDefined(bool isDefined) { IsDefined = isDefined; }
 413
 414   /// \brief Whether this method overrides any other in the class hierarchy.
 415   ///
 416   /// A method is said to override any method in the class's
 417   /// base classes, its protocols, or its categories' protocols, that has
 418   /// the same selector and is of the same kind (class or instance).
 419   /// A method in an implementation is not considered as overriding the same
 420   /// method in the interface or its categories.
 421   bool isOverriding() const { return IsOverriding; }
 422   void setOverriding(bool isOverriding) { IsOverriding = isOverriding; }
 423
 424   /// \brief Return overridden methods for the given \p Method.
 425   ///
 426   /// An ObjC method is considered to override any method in the class's
 427   /// base classes (and base's categories), its protocols, or its categories'
 428   /// protocols, that has
 429   /// the same selector and is of the same kind (class or instance).
 430   /// A method in an implementation is not considered as overriding the same
 431   /// method in the interface or its categories.
 432   void getOverriddenMethods(
 433                      SmallVectorImpl<const ObjCMethodDecl *> &Overridden) const;
 434
 435   /// \brief True if the method was a definition but its body was skipped.
 436   bool hasSkippedBody() const { return HasSkippedBody; }
 437   void setHasSkippedBody(bool Skipped = true) { HasSkippedBody = Skipped; }
 438
 439   /// \brief Returns the property associated with this method's selector.
 440   ///
 441   /// Note that even if this particular method is not marked as a property
 442   /// accessor, it is still possible for it to match a property declared in a
 443   /// superclass. Pass \c false if you only want to check the current class.
 444   const ObjCPropertyDecl *findPropertyDecl(bool CheckOverrides = true) const;
 445
 446   // Related to protocols declared in  \@protocol
 447   void setDeclImplementation(ImplementationControl ic) {
 448     DeclImplementation = ic;
 449   }
 450   ImplementationControl getImplementationControl() const {
 451     return ImplementationControl(DeclImplementation);
 452   }
 453
 454   /// \brief Determine whether this method has a body.
 455   virtual bool hasBody() const { return Body; }
 456
 457   /// \brief Retrieve the body of this method, if it has one.
 458   virtual Stmt *getBody() const;
 459
 460   void setLazyBody(uint64_t Offset) { Body = Offset; }
 461
 462   CompoundStmt *getCompoundBody() { return (CompoundStmt*)getBody(); }
 463   void setBody(Stmt *B) { Body = B; }
 464
 465   /// \brief Returns whether this specific method is a definition.
 466   bool isThisDeclarationADefinition() const { return Body; }
 467
 468   // Implement isa/cast/dyncast/etc.
 469   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
 470   static bool classofKind(Kind K) { return K == ObjCMethod; }
 471   static DeclContext *castToDeclContext(const ObjCMethodDecl *D) {
 472     return static_cast<DeclContext *>(const_cast<ObjCMethodDecl*>(D));
 473   }
 474   static ObjCMethodDecl *castFromDeclContext(const DeclContext *DC) {
 475     return static_cast<ObjCMethodDecl *>(const_cast<DeclContext*>(DC));
 476   }
 477
 478   friend class ASTDeclReader;
 479   friend class ASTDeclWriter;
 480 };
 481
 482 /// ObjCContainerDecl - Represents a container for method declarations.
 483 /// Current sub-classes are ObjCInterfaceDecl, ObjCCategoryDecl,
 484 /// ObjCProtocolDecl, and ObjCImplDecl.
 485 ///
 486 class ObjCContainerDecl : public NamedDecl, public DeclContext {
 487   virtual void anchor();
 488
 489   SourceLocation AtStart;
 490
 491   // These two locations in the range mark the end of the method container.
 492   // The first points to the '@' token, and the second to the 'end' token.
 493   SourceRange AtEnd;
 494 public:
 495
 496   ObjCContainerDecl(Kind DK, DeclContext *DC,
 497                     IdentifierInfo *Id, SourceLocation nameLoc,
 498                     SourceLocation atStartLoc)
 499     : NamedDecl(DK, DC, nameLoc, Id), DeclContext(DK), AtStart(atStartLoc) {}
 500
 501   // Iterator access to properties.
 502   typedef specific_decl_iterator<ObjCPropertyDecl> prop_iterator;
 503   prop_iterator prop_begin() const {
 504     return prop_iterator(decls_begin());
 505   }
 506   prop_iterator prop_end() const {
 507     return prop_iterator(decls_end());
 508   }
 509
 510   // Iterator access to instance/class methods.
 511   typedef specific_decl_iterator<ObjCMethodDecl> method_iterator;
 512   method_iterator meth_begin() const {
 513     return method_iterator(decls_begin());
 514   }
 515   method_iterator meth_end() const {
 516     return method_iterator(decls_end());
 517   }
 518
 519   typedef filtered_decl_iterator<ObjCMethodDecl,
 520                                  &ObjCMethodDecl::isInstanceMethod>
 521     instmeth_iterator;
 522   instmeth_iterator instmeth_begin() const {
 523     return instmeth_iterator(decls_begin());
 524   }
 525   instmeth_iterator instmeth_end() const {
 526     return instmeth_iterator(decls_end());
 527   }
 528
 529   typedef filtered_decl_iterator<ObjCMethodDecl,
 530                                  &ObjCMethodDecl::isClassMethod>
 531     classmeth_iterator;
 532   classmeth_iterator classmeth_begin() const {
 533     return classmeth_iterator(decls_begin());
 534   }
 535   classmeth_iterator classmeth_end() const {
 536     return classmeth_iterator(decls_end());
 537   }
 538
 539   // Get the local instance/class method declared in this interface.
 540   ObjCMethodDecl *getMethod(Selector Sel, bool isInstance,
 541                             bool AllowHidden = false) const;
 542   ObjCMethodDecl *getInstanceMethod(Selector Sel,
 543                                     bool AllowHidden = false) const {
 544     return getMethod(Sel, true/*isInstance*/, AllowHidden);
 545   }
 546   ObjCMethodDecl *getClassMethod(Selector Sel, bool AllowHidden = false) const {
 547     return getMethod(Sel, false/*isInstance*/, AllowHidden);
 548   }
 549   bool HasUserDeclaredSetterMethod(const ObjCPropertyDecl *P) const;
 550   ObjCIvarDecl *getIvarDecl(IdentifierInfo *Id) const;
 551
 552   ObjCPropertyDecl *FindPropertyDeclaration(IdentifierInfo *PropertyId) const;
 553
 554   typedef llvm::DenseMap<IdentifierInfo*, ObjCPropertyDecl*> PropertyMap;
 555
 556   typedef llvm::SmallVector<ObjCPropertyDecl*, 8> PropertyDeclOrder;
 557
 558   /// This routine collects list of properties to be implemented in the class.
 559   /// This includes, class's and its conforming protocols' properties.
 560   /// Note, the superclass's properties are not included in the list.
 561   virtual void collectPropertiesToImplement(PropertyMap &PM,
 562                                             PropertyDeclOrder &PO) const {}
 563
 564   SourceLocation getAtStartLoc() const { return AtStart; }
 565   void setAtStartLoc(SourceLocation Loc) { AtStart = Loc; }
 566
 567   // Marks the end of the container.
 568   SourceRange getAtEndRange() const {
 569     return AtEnd;
 570   }
 571   void setAtEndRange(SourceRange atEnd) {
 572     AtEnd = atEnd;
 573   }
 574
 575   virtual SourceRange getSourceRange() const LLVM_READONLY {
 576     return SourceRange(AtStart, getAtEndRange().getEnd());
 577   }
 578
 579   // Implement isa/cast/dyncast/etc.
 580   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
 581   static bool classofKind(Kind K) {
 582     return K >= firstObjCContainer &&
 583            K <= lastObjCContainer;
 584   }
 585
 586   static DeclContext *castToDeclContext(const ObjCContainerDecl *D) {
 587     return static_cast<DeclContext *>(const_cast<ObjCContainerDecl*>(D));
 588   }
 589   static ObjCContainerDecl *castFromDeclContext(const DeclContext *DC) {
 590     return static_cast<ObjCContainerDecl *>(const_cast<DeclContext*>(DC));
 591   }
 592 };
 593
 594 /// \brief Represents an ObjC class declaration.
 595 ///
 596 /// For example:
 597 ///
 598 /// \code
 599 ///   // MostPrimitive declares no super class (not particularly useful).
 600 ///   \@interface MostPrimitive
 601 ///     // no instance variables or methods.
 602 ///   \@end
 603 ///
 604 ///   // NSResponder inherits from NSObject & implements NSCoding (a protocol).
 605 ///   \@interface NSResponder : NSObject \<NSCoding>
 606 ///   { // instance variables are represented by ObjCIvarDecl.
 607 ///     id nextResponder; // nextResponder instance variable.
 608 ///   }
 609 ///   - (NSResponder *)nextResponder; // return a pointer to NSResponder.
 610 ///   - (void)mouseMoved:(NSEvent *)theEvent; // return void, takes a pointer
 611 ///   \@end                                    // to an NSEvent.
 612 /// \endcode
 613 ///
 614 ///   Unlike C/C++, forward class declarations are accomplished with \@class.
 615 ///   Unlike C/C++, \@class allows for a list of classes to be forward declared.
 616 ///   Unlike C++, ObjC is a single-rooted class model. In Cocoa, classes
 617 ///   typically inherit from NSObject (an exception is NSProxy).
 618 ///
 619 class ObjCInterfaceDecl : public ObjCContainerDecl
 620                         , public Redeclarable<ObjCInterfaceDecl> {
 621   virtual void anchor();
 622
 623   /// TypeForDecl - This indicates the Type object that represents this
 624   /// TypeDecl.  It is a cache maintained by ASTContext::getObjCInterfaceType
 625   mutable const Type *TypeForDecl;
 626   friend class ASTContext;
 627
 628   struct DefinitionData {
 629     /// \brief The definition of this class, for quick access from any
 630     /// declaration.
 631     ObjCInterfaceDecl *Definition;
 632
 633     /// Class's super class.
 634     ObjCInterfaceDecl *SuperClass;
 635
 636     /// Protocols referenced in the \@interface  declaration
 637     ObjCProtocolList ReferencedProtocols;
 638
 639     /// Protocols reference in both the \@interface and class extensions.
 640     ObjCList<ObjCProtocolDecl> AllReferencedProtocols;
 641
 642     /// \brief List of categories and class extensions defined for this class.
 643     ///
 644     /// Categories are stored as a linked list in the AST, since the categories
 645     /// and class extensions come long after the initial interface declaration,
 646     /// and we avoid dynamically-resized arrays in the AST wherever possible.
 647     ObjCCategoryDecl *CategoryList;
 648
 649     /// IvarList - List of all ivars defined by this class; including class
 650     /// extensions and implementation. This list is built lazily.
 651     ObjCIvarDecl *IvarList;
 652
 653     /// \brief Indicates that the contents of this Objective-C class will be
 654     /// completed by the external AST source when required.
 655     mutable bool ExternallyCompleted : 1;
 656
 657     /// \brief Indicates that the ivar cache does not yet include ivars
 658     /// declared in the implementation.
 659     mutable bool IvarListMissingImplementation : 1;
 660
 661     /// \brief The location of the superclass, if any.
 662     SourceLocation SuperClassLoc;
 663
 664     /// \brief The location of the last location in this declaration, before
 665     /// the properties/methods. For example, this will be the '>', '}', or
 666     /// identifier,
 667     SourceLocation EndLoc;
 668
 669     DefinitionData() : Definition(), SuperClass(), CategoryList(), IvarList(),
 670                        ExternallyCompleted(),
 671                        IvarListMissingImplementation(true) { }
 672   };
 673
 674   ObjCInterfaceDecl(DeclContext *DC, SourceLocation atLoc, IdentifierInfo *Id,
 675                     SourceLocation CLoc, ObjCInterfaceDecl *PrevDecl,
 676                     bool isInternal);
 677
 678   void LoadExternalDefinition() const;
 679
 680   /// \brief Contains a pointer to the data associated with this class,
 681   /// which will be NULL if this class has not yet been defined.
 682   ///
 683   /// The bit indicates when we don't need to check for out-of-date
 684   /// declarations. It will be set unless modules are enabled.
 685   llvm::PointerIntPair<DefinitionData *, 1, bool> Data;
 686
 687   DefinitionData &data() const {
 688     assert(Data.getPointer() && "Declaration has no definition!");
 689     return *Data.getPointer();
 690   }
 691
 692   /// \brief Allocate the definition data for this class.
 693   void allocateDefinitionData();
 694
 695   typedef Redeclarable<ObjCInterfaceDecl> redeclarable_base;
 696   virtual ObjCInterfaceDecl *getNextRedeclaration() {
 697     return RedeclLink.getNext();
 698   }
 699   virtual ObjCInterfaceDecl *getPreviousDeclImpl() {
 700     return getPreviousDecl();
 701   }
 702   virtual ObjCInterfaceDecl *getMostRecentDeclImpl() {
 703     return getMostRecentDecl();
 704   }
 705
 706 public:
 707   static ObjCInterfaceDecl *Create(const ASTContext &C, DeclContext *DC,
 708                                    SourceLocation atLoc,
 709                                    IdentifierInfo *Id,
 710                                    ObjCInterfaceDecl *PrevDecl,
 711                                    SourceLocation ClassLoc = SourceLocation(),
 712                                    bool isInternal = false);
 713
 714   static ObjCInterfaceDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 715
 716   virtual SourceRange getSourceRange() const LLVM_READONLY {
 717     if (isThisDeclarationADefinition())
 718       return ObjCContainerDecl::getSourceRange();
 719
 720     return SourceRange(getAtStartLoc(), getLocation());
 721   }
 722
 723   /// \brief Indicate that this Objective-C class is complete, but that
 724   /// the external AST source will be responsible for filling in its contents
 725   /// when a complete class is required.
 726   void setExternallyCompleted();
 727
 728   const ObjCProtocolList &getReferencedProtocols() const {
 729     assert(hasDefinition() && "Caller did not check for forward reference!");
 730     if (data().ExternallyCompleted)
 731       LoadExternalDefinition();
 732
 733     return data().ReferencedProtocols;
 734   }
 735
 736   ObjCImplementationDecl *getImplementation() const;
 737   void setImplementation(ObjCImplementationDecl *ImplD);
 738
 739   ObjCCategoryDecl *FindCategoryDeclaration(IdentifierInfo *CategoryId) const;
 740
 741   // Get the local instance/class method declared in a category.
 742   ObjCMethodDecl *getCategoryInstanceMethod(Selector Sel) const;
 743   ObjCMethodDecl *getCategoryClassMethod(Selector Sel) const;
 744   ObjCMethodDecl *getCategoryMethod(Selector Sel, bool isInstance) const {
 745     return isInstance ? getInstanceMethod(Sel)
 746                       : getClassMethod(Sel);
 747   }
 748
 749   typedef ObjCProtocolList::iterator protocol_iterator;
 750
 751   protocol_iterator protocol_begin() const {
 752     // FIXME: Should make sure no callers ever do this.
 753     if (!hasDefinition())
 754       return protocol_iterator();
 755
 756     if (data().ExternallyCompleted)
 757       LoadExternalDefinition();
 758
 759     return data().ReferencedProtocols.begin();
 760   }
 761   protocol_iterator protocol_end() const {
 762     // FIXME: Should make sure no callers ever do this.
 763     if (!hasDefinition())
 764       return protocol_iterator();
 765
 766     if (data().ExternallyCompleted)
 767       LoadExternalDefinition();
 768
 769     return data().ReferencedProtocols.end();
 770   }
 771
 772   typedef ObjCProtocolList::loc_iterator protocol_loc_iterator;
 773
 774   protocol_loc_iterator protocol_loc_begin() const {
 775     // FIXME: Should make sure no callers ever do this.
 776     if (!hasDefinition())
 777       return protocol_loc_iterator();
 778
 779     if (data().ExternallyCompleted)
 780       LoadExternalDefinition();
 781
 782     return data().ReferencedProtocols.loc_begin();
 783   }
 784
 785   protocol_loc_iterator protocol_loc_end() const {
 786     // FIXME: Should make sure no callers ever do this.
 787     if (!hasDefinition())
 788       return protocol_loc_iterator();
 789
 790     if (data().ExternallyCompleted)
 791       LoadExternalDefinition();
 792
 793     return data().ReferencedProtocols.loc_end();
 794   }
 795
 796   typedef ObjCList<ObjCProtocolDecl>::iterator all_protocol_iterator;
 797
 798   all_protocol_iterator all_referenced_protocol_begin() const {
 799     // FIXME: Should make sure no callers ever do this.
 800     if (!hasDefinition())
 801       return all_protocol_iterator();
 802
 803     if (data().ExternallyCompleted)
 804       LoadExternalDefinition();
 805
 806     return data().AllReferencedProtocols.empty()
 807              ? protocol_begin()
 808              : data().AllReferencedProtocols.begin();
 809   }
 810   all_protocol_iterator all_referenced_protocol_end() const {
 811     // FIXME: Should make sure no callers ever do this.
 812     if (!hasDefinition())
 813       return all_protocol_iterator();
 814
 815     if (data().ExternallyCompleted)
 816       LoadExternalDefinition();
 817
 818     return data().AllReferencedProtocols.empty()
 819              ? protocol_end()
 820              : data().AllReferencedProtocols.end();
 821   }
 822
 823   typedef specific_decl_iterator<ObjCIvarDecl> ivar_iterator;
 824
 825   ivar_iterator ivar_begin() const {
 826     if (const ObjCInterfaceDecl *Def = getDefinition())
 827       return ivar_iterator(Def->decls_begin());
 828
 829     // FIXME: Should make sure no callers ever do this.
 830     return ivar_iterator();
 831   }
 832   ivar_iterator ivar_end() const {
 833     if (const ObjCInterfaceDecl *Def = getDefinition())
 834       return ivar_iterator(Def->decls_end());
 835
 836     // FIXME: Should make sure no callers ever do this.
 837     return ivar_iterator();
 838   }
 839
 840   unsigned ivar_size() const {
 841     return std::distance(ivar_begin(), ivar_end());
 842   }
 843
 844   bool ivar_empty() const { return ivar_begin() == ivar_end(); }
 845
 846   ObjCIvarDecl *all_declared_ivar_begin();
 847   const ObjCIvarDecl *all_declared_ivar_begin() const {
 848     // Even though this modifies IvarList, it's conceptually const:
 849     // the ivar chain is essentially a cached property of ObjCInterfaceDecl.
 850     return const_cast<ObjCInterfaceDecl *>(this)->all_declared_ivar_begin();
 851   }
 852   void setIvarList(ObjCIvarDecl *ivar) { data().IvarList = ivar; }
 853
 854   /// setProtocolList - Set the list of protocols that this interface
 855   /// implements.
 856   void setProtocolList(ObjCProtocolDecl *const* List, unsigned Num,
 857                        const SourceLocation *Locs, ASTContext &C) {
 858     data().ReferencedProtocols.set(List, Num, Locs, C);
 859   }
 860
 861   /// mergeClassExtensionProtocolList - Merge class extension's protocol list
 862   /// into the protocol list for this class.
 863   void mergeClassExtensionProtocolList(ObjCProtocolDecl *const* List,
 864                                        unsigned Num,
 865                                        ASTContext &C);
 866
 867   /// \brief Determine whether this particular declaration of this class is
 868   /// actually also a definition.
 869   bool isThisDeclarationADefinition() const {
 870     return getDefinition() == this;
 871   }
 872
 873   /// \brief Determine whether this class has been defined.
 874   bool hasDefinition() const {
 875     // If the name of this class is out-of-date, bring it up-to-date, which
 876     // might bring in a definition.
 877     // Note: a null value indicates that we don't have a definition and that
 878     // modules are enabled.
 879     if (!Data.getOpaqueValue()) {
 880       if (IdentifierInfo *II = getIdentifier()) {
 881         if (II->isOutOfDate()) {
 882           updateOutOfDate(*II);
 883         }
 884       }
 885     }
 886
 887     return Data.getPointer();
 888   }
 889
 890   /// \brief Retrieve the definition of this class, or NULL if this class
 891   /// has been forward-declared (with \@class) but not yet defined (with
 892   /// \@interface).
 893   ObjCInterfaceDecl *getDefinition() {
 894     return hasDefinition()? Data.getPointer()->Definition : 0;
 895   }
 896
 897   /// \brief Retrieve the definition of this class, or NULL if this class
 898   /// has been forward-declared (with \@class) but not yet defined (with
 899   /// \@interface).
 900   const ObjCInterfaceDecl *getDefinition() const {
 901     return hasDefinition()? Data.getPointer()->Definition : 0;
 902   }
 903
 904   /// \brief Starts the definition of this Objective-C class, taking it from
 905   /// a forward declaration (\@class) to a definition (\@interface).
 906   void startDefinition();
 907
 908   ObjCInterfaceDecl *getSuperClass() const {
 909     // FIXME: Should make sure no callers ever do this.
 910     if (!hasDefinition())
 911       return 0;
 912
 913     if (data().ExternallyCompleted)
 914       LoadExternalDefinition();
 915
 916     return data().SuperClass;
 917   }
 918
 919   void setSuperClass(ObjCInterfaceDecl * superCls) {
 920     data().SuperClass =
 921       (superCls && superCls->hasDefinition()) ? superCls->getDefinition()
 922                                               : superCls;
 923   }
 924
 925   /// \brief Iterator that walks over the list of categories, filtering out
 926   /// those that do not meet specific criteria.
 927   ///
 928   /// This class template is used for the various permutations of category
 929   /// and extension iterators.
 930   template<bool (*Filter)(ObjCCategoryDecl *)>
 931   class filtered_category_iterator {
 932     ObjCCategoryDecl *Current;
 933
 934     void findAcceptableCategory();
 935
 936   public:
 937     typedef ObjCCategoryDecl *      value_type;
 938     typedef value_type              reference;
 939     typedef value_type              pointer;
 940     typedef std::ptrdiff_t          difference_type;
 941     typedef std::input_iterator_tag iterator_category;
 942
 943     filtered_category_iterator() : Current(0) { }
 944     explicit filtered_category_iterator(ObjCCategoryDecl *Current)
 945       : Current(Current)
 946     {
 947       findAcceptableCategory();
 948     }
 949
 950     reference operator*() const { return Current; }
 951     pointer operator->() const { return Current; }
 952
 953     filtered_category_iterator &operator++();
 954
 955     filtered_category_iterator operator++(int) {
 956       filtered_category_iterator Tmp = *this;
 957       ++(*this);
 958       return Tmp;
 959     }
 960
 961     friend bool operator==(filtered_category_iterator X,
 962                            filtered_category_iterator Y) {
 963       return X.Current == Y.Current;
 964     }
 965
 966     friend bool operator!=(filtered_category_iterator X,
 967                            filtered_category_iterator Y) {
 968       return X.Current != Y.Current;
 969     }
 970   };
 971
 972 private:
 973   /// \brief Test whether the given category is visible.
 974   ///
 975   /// Used in the \c visible_categories_iterator.
 976   static bool isVisibleCategory(ObjCCategoryDecl *Cat);
 977
 978 public:
 979   /// \brief Iterator that walks over the list of categories and extensions
 980   /// that are visible, i.e., not hidden in a non-imported submodule.
 981   typedef filtered_category_iterator<isVisibleCategory>
 982     visible_categories_iterator;
 983
 984   /// \brief Retrieve an iterator to the beginning of the visible-categories
 985   /// list.
 986   visible_categories_iterator visible_categories_begin() const {
 987     return visible_categories_iterator(getCategoryListRaw());
 988   }
 989
 990   /// \brief Retrieve an iterator to the end of the visible-categories list.
 991   visible_categories_iterator visible_categories_end() const {
 992     return visible_categories_iterator();
 993   }
 994
 995   /// \brief Determine whether the visible-categories list is empty.
 996   bool visible_categories_empty() const {
 997     return visible_categories_begin() == visible_categories_end();
 998   }
 999
1000 private:
1001   /// \brief Test whether the given category... is a category.
1002   ///
1003   /// Used in the \c known_categories_iterator.
1004   static bool isKnownCategory(ObjCCategoryDecl *) { return true; }
1005
1006 public:
1007   /// \brief Iterator that walks over all of the known categories and
1008   /// extensions, including those that are hidden.
1009   typedef filtered_category_iterator<isKnownCategory> known_categories_iterator;
1010
1011   /// \brief Retrieve an iterator to the beginning of the known-categories
1012   /// list.
1013   known_categories_iterator known_categories_begin() const {
1014     return known_categories_iterator(getCategoryListRaw());
1015   }
1016
1017   /// \brief Retrieve an iterator to the end of the known-categories list.
1018   known_categories_iterator known_categories_end() const {
1019     return known_categories_iterator();
1020   }
1021
1022   /// \brief Determine whether the known-categories list is empty.
1023   bool known_categories_empty() const {
1024     return known_categories_begin() == known_categories_end();
1025   }
1026
1027 private:
1028   /// \brief Test whether the given category is a visible extension.
1029   ///
1030   /// Used in the \c visible_extensions_iterator.
1031   static bool isVisibleExtension(ObjCCategoryDecl *Cat);
1032
1033 public:
1034   /// \brief Iterator that walks over all of the visible extensions, skipping
1035   /// any that are known but hidden.
1036   typedef filtered_category_iterator<isVisibleExtension>
1037     visible_extensions_iterator;
1038
1039   /// \brief Retrieve an iterator to the beginning of the visible-extensions
1040   /// list.
1041   visible_extensions_iterator visible_extensions_begin() const {
1042     return visible_extensions_iterator(getCategoryListRaw());
1043   }
1044
1045   /// \brief Retrieve an iterator to the end of the visible-extensions list.
1046   visible_extensions_iterator visible_extensions_end() const {
1047     return visible_extensions_iterator();
1048   }
1049
1050   /// \brief Determine whether the visible-extensions list is empty.
1051   bool visible_extensions_empty() const {
1052     return visible_extensions_begin() == visible_extensions_end();
1053   }
1054
1055 private:
1056   /// \brief Test whether the given category is an extension.
1057   ///
1058   /// Used in the \c known_extensions_iterator.
1059   static bool isKnownExtension(ObjCCategoryDecl *Cat);
1060
1061 public:
1062   /// \brief Iterator that walks over all of the known extensions.
1063   typedef filtered_category_iterator<isKnownExtension>
1064     known_extensions_iterator;
1065
1066   /// \brief Retrieve an iterator to the beginning of the known-extensions
1067   /// list.
1068   known_extensions_iterator known_extensions_begin() const {
1069     return known_extensions_iterator(getCategoryListRaw());
1070   }
1071
1072   /// \brief Retrieve an iterator to the end of the known-extensions list.
1073   known_extensions_iterator known_extensions_end() const {
1074     return known_extensions_iterator();
1075   }
1076
1077   /// \brief Determine whether the known-extensions list is empty.
1078   bool known_extensions_empty() const {
1079     return known_extensions_begin() == known_extensions_end();
1080   }
1081
1082   /// \brief Retrieve the raw pointer to the start of the category/extension
1083   /// list.
1084   ObjCCategoryDecl* getCategoryListRaw() const {
1085     // FIXME: Should make sure no callers ever do this.
1086     if (!hasDefinition())
1087       return 0;
1088
1089     if (data().ExternallyCompleted)
1090       LoadExternalDefinition();
1091
1092     return data().CategoryList;
1093   }
1094
1095   /// \brief Set the raw pointer to the start of the category/extension
1096   /// list.
1097   void setCategoryListRaw(ObjCCategoryDecl *category) {
1098     data().CategoryList = category;
1099   }
1100
1101   ObjCPropertyDecl
1102     *FindPropertyVisibleInPrimaryClass(IdentifierInfo *PropertyId) const;
1103
1104   virtual void collectPropertiesToImplement(PropertyMap &PM,
1105                                             PropertyDeclOrder &PO) const;
1106
1107   /// isSuperClassOf - Return true if this class is the specified class or is a
1108   /// super class of the specified interface class.
1109   bool isSuperClassOf(const ObjCInterfaceDecl *I) const {
1110     // If RHS is derived from LHS it is OK; else it is not OK.
1111     while (I != NULL) {
1112       if (declaresSameEntity(this, I))
1113         return true;
1114
1115       I = I->getSuperClass();
1116     }
1117     return false;
1118   }
1119
1120   /// isArcWeakrefUnavailable - Checks for a class or one of its super classes
1121   /// to be incompatible with __weak references. Returns true if it is.
1122   bool isArcWeakrefUnavailable() const;
1123
1124   /// isObjCRequiresPropertyDefs - Checks that a class or one of its super
1125   /// classes must not be auto-synthesized. Returns class decl. if it must not
1126   /// be; 0, otherwise.
1127   const ObjCInterfaceDecl *isObjCRequiresPropertyDefs() const;
1128
1129   ObjCIvarDecl *lookupInstanceVariable(IdentifierInfo *IVarName,
1130                                        ObjCInterfaceDecl *&ClassDeclared);
1131   ObjCIvarDecl *lookupInstanceVariable(IdentifierInfo *IVarName) {
1132     ObjCInterfaceDecl *ClassDeclared;
1133     return lookupInstanceVariable(IVarName, ClassDeclared);
1134   }
1135
1136   // Lookup a method. First, we search locally. If a method isn't
1137   // found, we search referenced protocols and class categories.
1138   ObjCMethodDecl *lookupMethod(Selector Sel, bool isInstance,
1139                                bool shallowCategoryLookup= false,
1140                                const ObjCCategoryDecl *C= 0) const;
1141   ObjCMethodDecl *lookupInstanceMethod(Selector Sel,
1142                             bool shallowCategoryLookup = false) const {
1143     return lookupMethod(Sel, true/*isInstance*/, shallowCategoryLookup);
1144   }
1145   ObjCMethodDecl *lookupClassMethod(Selector Sel,
1146                      bool shallowCategoryLookup = false) const {
1147     return lookupMethod(Sel, false/*isInstance*/, shallowCategoryLookup);
1148   }
1149   ObjCInterfaceDecl *lookupInheritedClass(const IdentifierInfo *ICName);
1150
1151   /// \brief Lookup a method in the classes implementation hierarchy.
1152   ObjCMethodDecl *lookupPrivateMethod(const Selector &Sel,
1153                                       bool Instance=true) const;
1154
1155   ObjCMethodDecl *lookupPrivateClassMethod(const Selector &Sel) {
1156     return lookupPrivateMethod(Sel, false);
1157   }
1158
1159   /// \brief Lookup a setter or getter in the class hierarchy,
1160   /// including in all categories except for category passed
1161   /// as argument.
1162   ObjCMethodDecl *lookupPropertyAccessor(const Selector Sel,
1163                                          const ObjCCategoryDecl *Cat) const {
1164     return lookupMethod(Sel, true/*isInstance*/,
1165                         false/*shallowCategoryLookup*/, Cat);
1166   }
1167
1168   SourceLocation getEndOfDefinitionLoc() const {
1169     if (!hasDefinition())
1170       return getLocation();
1171
1172     return data().EndLoc;
1173   }
1174
1175   void setEndOfDefinitionLoc(SourceLocation LE) { data().EndLoc = LE; }
1176
1177   void setSuperClassLoc(SourceLocation Loc) { data().SuperClassLoc = Loc; }
1178   SourceLocation getSuperClassLoc() const { return data().SuperClassLoc; }
1179
1180   /// isImplicitInterfaceDecl - check that this is an implicitly declared
1181   /// ObjCInterfaceDecl node. This is for legacy objective-c \@implementation
1182   /// declaration without an \@interface declaration.
1183   bool isImplicitInterfaceDecl() const {
1184     return hasDefinition() ? data().Definition->isImplicit() : isImplicit();
1185   }
1186
1187   /// ClassImplementsProtocol - Checks that 'lProto' protocol
1188   /// has been implemented in IDecl class, its super class or categories (if
1189   /// lookupCategory is true).
1190   bool ClassImplementsProtocol(ObjCProtocolDecl *lProto,
1191                                bool lookupCategory,
1192                                bool RHSIsQualifiedID = false);
1193
1194   typedef redeclarable_base::redecl_iterator redecl_iterator;
1195   using redeclarable_base::redecls_begin;
1196   using redeclarable_base::redecls_end;
1197   using redeclarable_base::getPreviousDecl;
1198   using redeclarable_base::getMostRecentDecl;
1199
1200   /// Retrieves the canonical declaration of this Objective-C class.
1201   ObjCInterfaceDecl *getCanonicalDecl() {
1202     return getFirstDeclaration();
1203   }
1204   const ObjCInterfaceDecl *getCanonicalDecl() const {
1205     return getFirstDeclaration();
1206   }
1207
1208   // Low-level accessor
1209   const Type *getTypeForDecl() const { return TypeForDecl; }
1210   void setTypeForDecl(const Type *TD) const { TypeForDecl = TD; }
1211
1212   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1213   static bool classofKind(Kind K) { return K == ObjCInterface; }
1214
1215   friend class ASTReader;
1216   friend class ASTDeclReader;
1217   friend class ASTDeclWriter;
1218 };
1219
1220 /// ObjCIvarDecl - Represents an ObjC instance variable. In general, ObjC
1221 /// instance variables are identical to C. The only exception is Objective-C
1222 /// supports C++ style access control. For example:
1223 ///
1224 ///   \@interface IvarExample : NSObject
1225 ///   {
1226 ///     id defaultToProtected;
1227 ///   \@public:
1228 ///     id canBePublic; // same as C++.
1229 ///   \@protected:
1230 ///     id canBeProtected; // same as C++.
1231 ///   \@package:
1232 ///     id canBePackage; // framework visibility (not available in C++).
1233 ///   }
1234 ///
1235 class ObjCIvarDecl : public FieldDecl {
1236   virtual void anchor();
1237
1238 public:
1239   enum AccessControl {
1240     None, Private, Protected, Public, Package
1241   };
1242
1243 private:
1244   ObjCIvarDecl(ObjCContainerDecl *DC, SourceLocation StartLoc,
1245                SourceLocation IdLoc, IdentifierInfo *Id,
1246                QualType T, TypeSourceInfo *TInfo, AccessControl ac, Expr *BW,
1247                bool synthesized)
1248     : FieldDecl(ObjCIvar, DC, StartLoc, IdLoc, Id, T, TInfo, BW,
1249                 /*Mutable=*/false, /*HasInit=*/ICIS_NoInit),
1250       NextIvar(0), DeclAccess(ac), Synthesized(synthesized) {}
1251
1252 public:
1253   static ObjCIvarDecl *Create(ASTContext &C, ObjCContainerDecl *DC,
1254                               SourceLocation StartLoc, SourceLocation IdLoc,
1255                               IdentifierInfo *Id, QualType T,
1256                               TypeSourceInfo *TInfo,
1257                               AccessControl ac, Expr *BW = NULL,
1258                               bool synthesized=false);
1259
1260   static ObjCIvarDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1261
1262   /// \brief Return the class interface that this ivar is logically contained
1263   /// in; this is either the interface where the ivar was declared, or the
1264   /// interface the ivar is conceptually a part of in the case of synthesized
1265   /// ivars.
1266   const ObjCInterfaceDecl *getContainingInterface() const;
1267
1268   ObjCIvarDecl *getNextIvar() { return NextIvar; }
1269   const ObjCIvarDecl *getNextIvar() const { return NextIvar; }
1270   void setNextIvar(ObjCIvarDecl *ivar) { NextIvar = ivar; }
1271
1272   void setAccessControl(AccessControl ac) { DeclAccess = ac; }
1273
1274   AccessControl getAccessControl() const { return AccessControl(DeclAccess); }
1275
1276   AccessControl getCanonicalAccessControl() const {
1277     return DeclAccess == None ? Protected : AccessControl(DeclAccess);
1278   }
1279
1280   void setSynthesize(bool synth) { Synthesized = synth; }
1281   bool getSynthesize() const { return Synthesized; }
1282
1283   // Implement isa/cast/dyncast/etc.
1284   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1285   static bool classofKind(Kind K) { return K == ObjCIvar; }
1286 private:
1287   /// NextIvar - Next Ivar in the list of ivars declared in class; class's
1288   /// extensions and class's implementation
1289   ObjCIvarDecl *NextIvar;
1290
1291   // NOTE: VC++ treats enums as signed, avoid using the AccessControl enum
1292   unsigned DeclAccess : 3;
1293   unsigned Synthesized : 1;
1294 };
1295
1296
1297 /// \brief Represents a field declaration created by an \@defs(...).
1298 class ObjCAtDefsFieldDecl : public FieldDecl {
1299   virtual void anchor();
1300   ObjCAtDefsFieldDecl(DeclContext *DC, SourceLocation StartLoc,
1301                       SourceLocation IdLoc, IdentifierInfo *Id,
1302                       QualType T, Expr *BW)
1303     : FieldDecl(ObjCAtDefsField, DC, StartLoc, IdLoc, Id, T,
1304                 /*TInfo=*/0, // FIXME: Do ObjCAtDefs have declarators ?
1305                 BW, /*Mutable=*/false, /*HasInit=*/ICIS_NoInit) {}
1306
1307 public:
1308   static ObjCAtDefsFieldDecl *Create(ASTContext &C, DeclContext *DC,
1309                                      SourceLocation StartLoc,
1310                                      SourceLocation IdLoc, IdentifierInfo *Id,
1311                                      QualType T, Expr *BW);
1312
1313   static ObjCAtDefsFieldDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1314
1315   // Implement isa/cast/dyncast/etc.
1316   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1317   static bool classofKind(Kind K) { return K == ObjCAtDefsField; }
1318 };
1319
1320 /// \brief Represents an Objective-C protocol declaration.
1321 ///
1322 /// Objective-C protocols declare a pure abstract type (i.e., no instance
1323 /// variables are permitted).  Protocols originally drew inspiration from
1324 /// C++ pure virtual functions (a C++ feature with nice semantics and lousy
1325 /// syntax:-). Here is an example:
1326 ///
1327 /// \code
1328 /// \@protocol NSDraggingInfo <refproto1, refproto2>
1329 /// - (NSWindow *)draggingDestinationWindow;
1330 /// - (NSImage *)draggedImage;
1331 /// \@end
1332 /// \endcode
1333 ///
1334 /// This says that NSDraggingInfo requires two methods and requires everything
1335 /// that the two "referenced protocols" 'refproto1' and 'refproto2' require as
1336 /// well.
1337 ///
1338 /// \code
1339 /// \@interface ImplementsNSDraggingInfo : NSObject \<NSDraggingInfo>
1340 /// \@end
1341 /// \endcode
1342 ///
1343 /// ObjC protocols inspired Java interfaces. Unlike Java, ObjC classes and
1344 /// protocols are in distinct namespaces. For example, Cocoa defines both
1345 /// an NSObject protocol and class (which isn't allowed in Java). As a result,
1346 /// protocols are referenced using angle brackets as follows:
1347 ///
1348 /// id \<NSDraggingInfo> anyObjectThatImplementsNSDraggingInfo;
1349 ///
1350 class ObjCProtocolDecl : public ObjCContainerDecl,
1351                          public Redeclarable<ObjCProtocolDecl> {
1352   virtual void anchor();
1353
1354   struct DefinitionData {
1355     // \brief The declaration that defines this protocol.
1356     ObjCProtocolDecl *Definition;
1357
1358     /// \brief Referenced protocols
1359     ObjCProtocolList ReferencedProtocols;
1360   };
1361
1362   /// \brief Contains a pointer to the data associated with this class,
1363   /// which will be NULL if this class has not yet been defined.
1364   ///
1365   /// The bit indicates when we don't need to check for out-of-date
1366   /// declarations. It will be set unless modules are enabled.
1367   llvm::PointerIntPair<DefinitionData *, 1, bool> Data;
1368
1369   DefinitionData &data() const {
1370     assert(Data.getPointer() && "Objective-C protocol has no definition!");
1371     return *Data.getPointer();
1372   }
1373
1374   ObjCProtocolDecl(DeclContext *DC, IdentifierInfo *Id,
1375                    SourceLocation nameLoc, SourceLocation atStartLoc,
1376                    ObjCProtocolDecl *PrevDecl);
1377
1378   void allocateDefinitionData();
1379
1380   typedef Redeclarable<ObjCProtocolDecl> redeclarable_base;
1381   virtual ObjCProtocolDecl *getNextRedeclaration() {
1382     return RedeclLink.getNext();
1383   }
1384   virtual ObjCProtocolDecl *getPreviousDeclImpl() {
1385     return getPreviousDecl();
1386   }
1387   virtual ObjCProtocolDecl *getMostRecentDeclImpl() {
1388     return getMostRecentDecl();
1389   }
1390
1391 public:
1392   static ObjCProtocolDecl *Create(ASTContext &C, DeclContext *DC,
1393                                   IdentifierInfo *Id,
1394                                   SourceLocation nameLoc,
1395                                   SourceLocation atStartLoc,
1396                                   ObjCProtocolDecl *PrevDecl);
1397
1398   static ObjCProtocolDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1399
1400   const ObjCProtocolList &getReferencedProtocols() const {
1401     assert(hasDefinition() && "No definition available!");
1402     return data().ReferencedProtocols;
1403   }
1404   typedef ObjCProtocolList::iterator protocol_iterator;
1405   protocol_iterator protocol_begin() const {
1406     if (!hasDefinition())
1407       return protocol_iterator();
1408
1409     return data().ReferencedProtocols.begin();
1410   }
1411   protocol_iterator protocol_end() const {
1412     if (!hasDefinition())
1413       return protocol_iterator();
1414
1415     return data().ReferencedProtocols.end();
1416   }
1417   typedef ObjCProtocolList::loc_iterator protocol_loc_iterator;
1418   protocol_loc_iterator protocol_loc_begin() const {
1419     if (!hasDefinition())
1420       return protocol_loc_iterator();
1421
1422     return data().ReferencedProtocols.loc_begin();
1423   }
1424   protocol_loc_iterator protocol_loc_end() const {
1425     if (!hasDefinition())
1426       return protocol_loc_iterator();
1427
1428     return data().ReferencedProtocols.loc_end();
1429   }
1430   unsigned protocol_size() const {
1431     if (!hasDefinition())
1432       return 0;
1433
1434     return data().ReferencedProtocols.size();
1435   }
1436
1437   /// setProtocolList - Set the list of protocols that this interface
1438   /// implements.
1439   void setProtocolList(ObjCProtocolDecl *const*List, unsigned Num,
1440                        const SourceLocation *Locs, ASTContext &C) {
1441     assert(hasDefinition() && "Protocol is not defined");
1442     data().ReferencedProtocols.set(List, Num, Locs, C);
1443   }
1444
1445   ObjCProtocolDecl *lookupProtocolNamed(IdentifierInfo *PName);
1446
1447   // Lookup a method. First, we search locally. If a method isn't
1448   // found, we search referenced protocols and class categories.
1449   ObjCMethodDecl *lookupMethod(Selector Sel, bool isInstance) const;
1450   ObjCMethodDecl *lookupInstanceMethod(Selector Sel) const {
1451     return lookupMethod(Sel, true/*isInstance*/);
1452   }
1453   ObjCMethodDecl *lookupClassMethod(Selector Sel) const {
1454     return lookupMethod(Sel, false/*isInstance*/);
1455   }
1456
1457   /// \brief Determine whether this protocol has a definition.
1458   bool hasDefinition() const {
1459     // If the name of this protocol is out-of-date, bring it up-to-date, which
1460     // might bring in a definition.
1461     // Note: a null value indicates that we don't have a definition and that
1462     // modules are enabled.
1463     if (!Data.getOpaqueValue()) {
1464       if (IdentifierInfo *II = getIdentifier()) {
1465         if (II->isOutOfDate()) {
1466           updateOutOfDate(*II);
1467         }
1468       }
1469     }
1470
1471     return Data.getPointer();
1472   }
1473
1474   /// \brief Retrieve the definition of this protocol, if any.
1475   ObjCProtocolDecl *getDefinition() {
1476     return hasDefinition()? Data.getPointer()->Definition : 0;
1477   }
1478
1479   /// \brief Retrieve the definition of this protocol, if any.
1480   const ObjCProtocolDecl *getDefinition() const {
1481     return hasDefinition()? Data.getPointer()->Definition : 0;
1482   }
1483
1484   /// \brief Determine whether this particular declaration is also the
1485   /// definition.
1486   bool isThisDeclarationADefinition() const {
1487     return getDefinition() == this;
1488   }
1489
1490   /// \brief Starts the definition of this Objective-C protocol.
1491   void startDefinition();
1492
1493   virtual SourceRange getSourceRange() const LLVM_READONLY {
1494     if (isThisDeclarationADefinition())
1495       return ObjCContainerDecl::getSourceRange();
1496
1497     return SourceRange(getAtStartLoc(), getLocation());
1498   }
1499
1500   typedef redeclarable_base::redecl_iterator redecl_iterator;
1501   using redeclarable_base::redecls_begin;
1502   using redeclarable_base::redecls_end;
1503   using redeclarable_base::getPreviousDecl;
1504   using redeclarable_base::getMostRecentDecl;
1505
1506   /// Retrieves the canonical declaration of this Objective-C protocol.
1507   ObjCProtocolDecl *getCanonicalDecl() {
1508     return getFirstDeclaration();
1509   }
1510   const ObjCProtocolDecl *getCanonicalDecl() const {
1511     return getFirstDeclaration();
1512   }
1513
1514   virtual void collectPropertiesToImplement(PropertyMap &PM,
1515                                             PropertyDeclOrder &PO) const;
1516
1517   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1518   static bool classofKind(Kind K) { return K == ObjCProtocol; }
1519
1520   friend class ASTReader;
1521   friend class ASTDeclReader;
1522   friend class ASTDeclWriter;
1523 };
1524
1525 /// ObjCCategoryDecl - Represents a category declaration. A category allows
1526 /// you to add methods to an existing class (without subclassing or modifying
1527 /// the original class interface or implementation:-). Categories don't allow
1528 /// you to add instance data. The following example adds "myMethod" to all
1529 /// NSView's within a process:
1530 ///
1531 /// \@interface NSView (MyViewMethods)
1532 /// - myMethod;
1533 /// \@end
1534 ///
1535 /// Categories also allow you to split the implementation of a class across
1536 /// several files (a feature more naturally supported in C++).
1537 ///
1538 /// Categories were originally inspired by dynamic languages such as Common
1539 /// Lisp and Smalltalk.  More traditional class-based languages (C++, Java)
1540 /// don't support this level of dynamism, which is both powerful and dangerous.
1541 ///
1542 class ObjCCategoryDecl : public ObjCContainerDecl {
1543   virtual void anchor();
1544
1545   /// Interface belonging to this category
1546   ObjCInterfaceDecl *ClassInterface;
1547
1548   /// referenced protocols in this category.
1549   ObjCProtocolList ReferencedProtocols;
1550
1551   /// Next category belonging to this class.
1552   /// FIXME: this should not be a singly-linked list.  Move storage elsewhere.
1553   ObjCCategoryDecl *NextClassCategory;
1554
1555   /// \brief The location of the category name in this declaration.
1556   SourceLocation CategoryNameLoc;
1557
1558   /// class extension may have private ivars.
1559   SourceLocation IvarLBraceLoc;
1560   SourceLocation IvarRBraceLoc;
1561
1562   ObjCCategoryDecl(DeclContext *DC, SourceLocation AtLoc,
1563                    SourceLocation ClassNameLoc, SourceLocation CategoryNameLoc,
1564                    IdentifierInfo *Id, ObjCInterfaceDecl *IDecl,
1565                    SourceLocation IvarLBraceLoc=SourceLocation(),
1566                    SourceLocation IvarRBraceLoc=SourceLocation())
1567     : ObjCContainerDecl(ObjCCategory, DC, Id, ClassNameLoc, AtLoc),
1568       ClassInterface(IDecl), NextClassCategory(0),
1569       CategoryNameLoc(CategoryNameLoc),
1570       IvarLBraceLoc(IvarLBraceLoc), IvarRBraceLoc(IvarRBraceLoc) {
1571   }
1572
1573 public:
1574
1575   static ObjCCategoryDecl *Create(ASTContext &C, DeclContext *DC,
1576                                   SourceLocation AtLoc,
1577                                   SourceLocation ClassNameLoc,
1578                                   SourceLocation CategoryNameLoc,
1579                                   IdentifierInfo *Id,
1580                                   ObjCInterfaceDecl *IDecl,
1581                                   SourceLocation IvarLBraceLoc=SourceLocation(),
1582                                   SourceLocation IvarRBraceLoc=SourceLocation());
1583   static ObjCCategoryDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1584
1585   ObjCInterfaceDecl *getClassInterface() { return ClassInterface; }
1586   const ObjCInterfaceDecl *getClassInterface() const { return ClassInterface; }
1587
1588   ObjCCategoryImplDecl *getImplementation() const;
1589   void setImplementation(ObjCCategoryImplDecl *ImplD);
1590
1591   /// setProtocolList - Set the list of protocols that this interface
1592   /// implements.
1593   void setProtocolList(ObjCProtocolDecl *const*List, unsigned Num,
1594                        const SourceLocation *Locs, ASTContext &C) {
1595     ReferencedProtocols.set(List, Num, Locs, C);
1596   }
1597
1598   const ObjCProtocolList &getReferencedProtocols() const {
1599     return ReferencedProtocols;
1600   }
1601
1602   typedef ObjCProtocolList::iterator protocol_iterator;
1603   protocol_iterator protocol_begin() const {return ReferencedProtocols.begin();}
1604   protocol_iterator protocol_end() const { return ReferencedProtocols.end(); }
1605   unsigned protocol_size() const { return ReferencedProtocols.size(); }
1606   typedef ObjCProtocolList::loc_iterator protocol_loc_iterator;
1607   protocol_loc_iterator protocol_loc_begin() const {
1608     return ReferencedProtocols.loc_begin();
1609   }
1610   protocol_loc_iterator protocol_loc_end() const {
1611     return ReferencedProtocols.loc_end();
1612   }
1613
1614   ObjCCategoryDecl *getNextClassCategory() const { return NextClassCategory; }
1615
1616   /// \brief Retrieve the pointer to the next stored category (or extension),
1617   /// which may be hidden.
1618   ObjCCategoryDecl *getNextClassCategoryRaw() const {
1619     return NextClassCategory;
1620   }
1621
1622   bool IsClassExtension() const { return getIdentifier() == 0; }
1623
1624   typedef specific_decl_iterator<ObjCIvarDecl> ivar_iterator;
1625   ivar_iterator ivar_begin() const {
1626     return ivar_iterator(decls_begin());
1627   }
1628   ivar_iterator ivar_end() const {
1629     return ivar_iterator(decls_end());
1630   }
1631   unsigned ivar_size() const {
1632     return std::distance(ivar_begin(), ivar_end());
1633   }
1634   bool ivar_empty() const {
1635     return ivar_begin() == ivar_end();
1636   }
1637
1638   SourceLocation getCategoryNameLoc() const { return CategoryNameLoc; }
1639   void setCategoryNameLoc(SourceLocation Loc) { CategoryNameLoc = Loc; }
1640
1641   void setIvarLBraceLoc(SourceLocation Loc) { IvarLBraceLoc = Loc; }
1642   SourceLocation getIvarLBraceLoc() const { return IvarLBraceLoc; }
1643   void setIvarRBraceLoc(SourceLocation Loc) { IvarRBraceLoc = Loc; }
1644   SourceLocation getIvarRBraceLoc() const { return IvarRBraceLoc; }
1645
1646   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1647   static bool classofKind(Kind K) { return K == ObjCCategory; }
1648
1649   friend class ASTDeclReader;
1650   friend class ASTDeclWriter;
1651 };
1652
1653 class ObjCImplDecl : public ObjCContainerDecl {
1654   virtual void anchor();
1655
1656   /// Class interface for this class/category implementation
1657   ObjCInterfaceDecl *ClassInterface;
1658
1659 protected:
1660   ObjCImplDecl(Kind DK, DeclContext *DC,
1661                ObjCInterfaceDecl *classInterface,
1662                SourceLocation nameLoc, SourceLocation atStartLoc)
1663     : ObjCContainerDecl(DK, DC,
1664                         classInterface? classInterface->getIdentifier() : 0,
1665                         nameLoc, atStartLoc),
1666       ClassInterface(classInterface) {}
1667
1668 public:
1669   const ObjCInterfaceDecl *getClassInterface() const { return ClassInterface; }
1670   ObjCInterfaceDecl *getClassInterface() { return ClassInterface; }
1671   void setClassInterface(ObjCInterfaceDecl *IFace);
1672
1673   void addInstanceMethod(ObjCMethodDecl *method) {
1674     // FIXME: Context should be set correctly before we get here.
1675     method->setLexicalDeclContext(this);
1676     addDecl(method);
1677   }
1678   void addClassMethod(ObjCMethodDecl *method) {
1679     // FIXME: Context should be set correctly before we get here.
1680     method->setLexicalDeclContext(this);
1681     addDecl(method);
1682   }
1683
1684   void addPropertyImplementation(ObjCPropertyImplDecl *property);
1685
1686   ObjCPropertyImplDecl *FindPropertyImplDecl(IdentifierInfo *propertyId) const;
1687   ObjCPropertyImplDecl *FindPropertyImplIvarDecl(IdentifierInfo *ivarId) const;
1688
1689   // Iterator access to properties.
1690   typedef specific_decl_iterator<ObjCPropertyImplDecl> propimpl_iterator;
1691   propimpl_iterator propimpl_begin() const {
1692     return propimpl_iterator(decls_begin());
1693   }
1694   propimpl_iterator propimpl_end() const {
1695     return propimpl_iterator(decls_end());
1696   }
1697
1698   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1699   static bool classofKind(Kind K) {
1700     return K >= firstObjCImpl && K <= lastObjCImpl;
1701   }
1702 };
1703
1704 /// ObjCCategoryImplDecl - An object of this class encapsulates a category
1705 /// \@implementation declaration. If a category class has declaration of a
1706 /// property, its implementation must be specified in the category's
1707 /// \@implementation declaration. Example:
1708 /// \@interface I \@end
1709 /// \@interface I(CATEGORY)
1710 ///    \@property int p1, d1;
1711 /// \@end
1712 /// \@implementation I(CATEGORY)
1713 ///  \@dynamic p1,d1;
1714 /// \@end
1715 ///
1716 /// ObjCCategoryImplDecl
1717 class ObjCCategoryImplDecl : public ObjCImplDecl {
1718   virtual void anchor();
1719
1720   // Category name
1721   IdentifierInfo *Id;
1722
1723   // Category name location
1724   SourceLocation CategoryNameLoc;
1725
1726   ObjCCategoryImplDecl(DeclContext *DC, IdentifierInfo *Id,
1727                        ObjCInterfaceDecl *classInterface,
1728                        SourceLocation nameLoc, SourceLocation atStartLoc,
1729                        SourceLocation CategoryNameLoc)
1730     : ObjCImplDecl(ObjCCategoryImpl, DC, classInterface, nameLoc, atStartLoc),
1731       Id(Id), CategoryNameLoc(CategoryNameLoc) {}
1732 public:
1733   static ObjCCategoryImplDecl *Create(ASTContext &C, DeclContext *DC,
1734                                       IdentifierInfo *Id,
1735                                       ObjCInterfaceDecl *classInterface,
1736                                       SourceLocation nameLoc,
1737                                       SourceLocation atStartLoc,
1738                                       SourceLocation CategoryNameLoc);
1739   static ObjCCategoryImplDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1740
1741   /// getIdentifier - Get the identifier that names the category
1742   /// interface associated with this implementation.
1743   /// FIXME: This is a bad API, we are overriding the NamedDecl::getIdentifier()
1744   /// to mean something different. For example:
1745   /// ((NamedDecl *)SomeCategoryImplDecl)->getIdentifier()
1746   /// returns the class interface name, whereas
1747   /// ((ObjCCategoryImplDecl *)SomeCategoryImplDecl)->getIdentifier()
1748   /// returns the category name.
1749   IdentifierInfo *getIdentifier() const {
1750     return Id;
1751   }
1752   void setIdentifier(IdentifierInfo *II) { Id = II; }
1753
1754   ObjCCategoryDecl *getCategoryDecl() const;
1755
1756   SourceLocation getCategoryNameLoc() const { return CategoryNameLoc; }
1757
1758   /// getName - Get the name of identifier for the class interface associated
1759   /// with this implementation as a StringRef.
1760   //
1761   // FIXME: This is a bad API, we are overriding the NamedDecl::getName, to mean
1762   // something different.
1763   StringRef getName() const {
1764     return Id ? Id->getNameStart() : "";
1765   }
1766
1767   /// @brief Get the name of the class associated with this interface.
1768   //
1769   // FIXME: Deprecated, move clients to getName().
1770   std::string getNameAsString() const {
1771     return getName();
1772   }
1773
1774   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1775   static bool classofKind(Kind K) { return K == ObjCCategoryImpl;}
1776
1777   friend class ASTDeclReader;
1778   friend class ASTDeclWriter;
1779 };
1780
1781 raw_ostream &operator<<(raw_ostream &OS, const ObjCCategoryImplDecl &CID);
1782
1783 /// ObjCImplementationDecl - Represents a class definition - this is where
1784 /// method definitions are specified. For example:
1785 ///
1786 /// @code
1787 /// \@implementation MyClass
1788 /// - (void)myMethod { /* do something */ }
1789 /// \@end
1790 /// @endcode
1791 ///
1792 /// Typically, instance variables are specified in the class interface,
1793 /// *not* in the implementation. Nevertheless (for legacy reasons), we
1794 /// allow instance variables to be specified in the implementation.  When
1795 /// specified, they need to be *identical* to the interface.
1796 ///
1797 class ObjCImplementationDecl : public ObjCImplDecl {
1798   virtual void anchor();
1799   /// Implementation Class's super class.
1800   ObjCInterfaceDecl *SuperClass;
1801   SourceLocation SuperLoc;
1802
1803   /// \@implementation may have private ivars.
1804   SourceLocation IvarLBraceLoc;
1805   SourceLocation IvarRBraceLoc;
1806
1807   /// Support for ivar initialization.
1808   /// IvarInitializers - The arguments used to initialize the ivars
1809   CXXCtorInitializer **IvarInitializers;
1810   unsigned NumIvarInitializers;
1811
1812   /// Do the ivars of this class require initialization other than
1813   /// zero-initialization?
1814   bool HasNonZeroConstructors : 1;
1815
1816   /// Do the ivars of this class require non-trivial destruction?
1817   bool HasDestructors : 1;
1818
1819   ObjCImplementationDecl(DeclContext *DC,
1820                          ObjCInterfaceDecl *classInterface,
1821                          ObjCInterfaceDecl *superDecl,
1822                          SourceLocation nameLoc, SourceLocation atStartLoc,
1823                          SourceLocation superLoc = SourceLocation(),
1824                          SourceLocation IvarLBraceLoc=SourceLocation(),
1825                          SourceLocation IvarRBraceLoc=SourceLocation())
1826     : ObjCImplDecl(ObjCImplementation, DC, classInterface, nameLoc, atStartLoc),
1827        SuperClass(superDecl), SuperLoc(superLoc), IvarLBraceLoc(IvarLBraceLoc),
1828        IvarRBraceLoc(IvarRBraceLoc),
1829        IvarInitializers(0), NumIvarInitializers(0),
1830        HasNonZeroConstructors(false), HasDestructors(false) {}
1831 public:
1832   static ObjCImplementationDecl *Create(ASTContext &C, DeclContext *DC,
1833                                         ObjCInterfaceDecl *classInterface,
1834                                         ObjCInterfaceDecl *superDecl,
1835                                         SourceLocation nameLoc,
1836                                         SourceLocation atStartLoc,
1837                                      SourceLocation superLoc = SourceLocation(),
1838                                         SourceLocation IvarLBraceLoc=SourceLocation(),
1839                                         SourceLocation IvarRBraceLoc=SourceLocation());
1840
1841   static ObjCImplementationDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1842
1843   /// init_iterator - Iterates through the ivar initializer list.
1844   typedef CXXCtorInitializer **init_iterator;
1845
1846   /// init_const_iterator - Iterates through the ivar initializer list.
1847   typedef CXXCtorInitializer * const * init_const_iterator;
1848
1849   /// init_begin() - Retrieve an iterator to the first initializer.
1850   init_iterator       init_begin()       { return IvarInitializers; }
1851   /// begin() - Retrieve an iterator to the first initializer.
1852   init_const_iterator init_begin() const { return IvarInitializers; }
1853
1854   /// init_end() - Retrieve an iterator past the last initializer.
1855   init_iterator       init_end()       {
1856     return IvarInitializers + NumIvarInitializers;
1857   }
1858   /// end() - Retrieve an iterator past the last initializer.
1859   init_const_iterator init_end() const {
1860     return IvarInitializers + NumIvarInitializers;
1861   }
1862   /// getNumArgs - Number of ivars which must be initialized.
1863   unsigned getNumIvarInitializers() const {
1864     return NumIvarInitializers;
1865   }
1866
1867   void setNumIvarInitializers(unsigned numNumIvarInitializers) {
1868     NumIvarInitializers = numNumIvarInitializers;
1869   }
1870
1871   void setIvarInitializers(ASTContext &C,
1872                            CXXCtorInitializer ** initializers,
1873                            unsigned numInitializers);
1874
1875   /// Do any of the ivars of this class (not counting its base classes)
1876   /// require construction other than zero-initialization?
1877   bool hasNonZeroConstructors() const { return HasNonZeroConstructors; }
1878   void setHasNonZeroConstructors(bool val) { HasNonZeroConstructors = val; }
1879
1880   /// Do any of the ivars of this class (not counting its base classes)
1881   /// require non-trivial destruction?
1882   bool hasDestructors() const { return HasDestructors; }
1883   void setHasDestructors(bool val) { HasDestructors = val; }
1884
1885   /// getIdentifier - Get the identifier that names the class
1886   /// interface associated with this implementation.
1887   IdentifierInfo *getIdentifier() const {
1888     return getClassInterface()->getIdentifier();
1889   }
1890
1891   /// getName - Get the name of identifier for the class interface associated
1892   /// with this implementation as a StringRef.
1893   //
1894   // FIXME: This is a bad API, we are overriding the NamedDecl::getName, to mean
1895   // something different.
1896   StringRef getName() const {
1897     assert(getIdentifier() && "Name is not a simple identifier");
1898     return getIdentifier()->getName();
1899   }
1900
1901   /// @brief Get the name of the class associated with this interface.
1902   //
1903   // FIXME: Move to StringRef API.
1904   std::string getNameAsString() const {
1905     return getName();
1906   }
1907
1908   const ObjCInterfaceDecl *getSuperClass() const { return SuperClass; }
1909   ObjCInterfaceDecl *getSuperClass() { return SuperClass; }
1910   SourceLocation getSuperClassLoc() const { return SuperLoc; }
1911
1912   void setSuperClass(ObjCInterfaceDecl * superCls) { SuperClass = superCls; }
1913
1914   void setIvarLBraceLoc(SourceLocation Loc) { IvarLBraceLoc = Loc; }
1915   SourceLocation getIvarLBraceLoc() const { return IvarLBraceLoc; }
1916   void setIvarRBraceLoc(SourceLocation Loc) { IvarRBraceLoc = Loc; }
1917   SourceLocation getIvarRBraceLoc() const { return IvarRBraceLoc; }
1918
1919   typedef specific_decl_iterator<ObjCIvarDecl> ivar_iterator;
1920   ivar_iterator ivar_begin() const {
1921     return ivar_iterator(decls_begin());
1922   }
1923   ivar_iterator ivar_end() const {
1924     return ivar_iterator(decls_end());
1925   }
1926   unsigned ivar_size() const {
1927     return std::distance(ivar_begin(), ivar_end());
1928   }
1929   bool ivar_empty() const {
1930     return ivar_begin() == ivar_end();
1931   }
1932
1933   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1934   static bool classofKind(Kind K) { return K == ObjCImplementation; }
1935
1936   friend class ASTDeclReader;
1937   friend class ASTDeclWriter;
1938 };
1939
1940 raw_ostream &operator<<(raw_ostream &OS, const ObjCImplementationDecl &ID);
1941
1942 /// ObjCCompatibleAliasDecl - Represents alias of a class. This alias is
1943 /// declared as \@compatibility_alias alias class.
1944 class ObjCCompatibleAliasDecl : public NamedDecl {
1945   virtual void anchor();
1946   /// Class that this is an alias of.
1947   ObjCInterfaceDecl *AliasedClass;
1948
1949   ObjCCompatibleAliasDecl(DeclContext *DC, SourceLocation L, IdentifierInfo *Id,
1950                           ObjCInterfaceDecl* aliasedClass)
1951     : NamedDecl(ObjCCompatibleAlias, DC, L, Id), AliasedClass(aliasedClass) {}
1952 public:
1953   static ObjCCompatibleAliasDecl *Create(ASTContext &C, DeclContext *DC,
1954                                          SourceLocation L, IdentifierInfo *Id,
1955                                          ObjCInterfaceDecl* aliasedClass);
1956
1957   static ObjCCompatibleAliasDecl *CreateDeserialized(ASTContext &C,
1958                                                      unsigned ID);
1959
1960   const ObjCInterfaceDecl *getClassInterface() const { return AliasedClass; }
1961   ObjCInterfaceDecl *getClassInterface() { return AliasedClass; }
1962   void setClassInterface(ObjCInterfaceDecl *D) { AliasedClass = D; }
1963
1964   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1965   static bool classofKind(Kind K) { return K == ObjCCompatibleAlias; }
1966
1967 };
1968
1969 /// \brief Represents one property declaration in an Objective-C interface.
1970 ///
1971 /// For example:
1972 /// \code{.mm}
1973 /// \@property (assign, readwrite) int MyProperty;
1974 /// \endcode
1975 class ObjCPropertyDecl : public NamedDecl {
1976   virtual void anchor();
1977 public:
1978   enum PropertyAttributeKind {
1979     OBJC_PR_noattr    = 0x00,
1980     OBJC_PR_readonly  = 0x01,
1981     OBJC_PR_getter    = 0x02,
1982     OBJC_PR_assign    = 0x04,
1983     OBJC_PR_readwrite = 0x08,
1984     OBJC_PR_retain    = 0x10,
1985     OBJC_PR_copy      = 0x20,
1986     OBJC_PR_nonatomic = 0x40,
1987     OBJC_PR_setter    = 0x80,
1988     OBJC_PR_atomic    = 0x100,
1989     OBJC_PR_weak      = 0x200,
1990     OBJC_PR_strong    = 0x400,
1991     OBJC_PR_unsafe_unretained = 0x800
1992     // Adding a property should change NumPropertyAttrsBits
1993   };
1994
1995   enum {
1996     /// \brief Number of bits fitting all the property attributes.
1997     NumPropertyAttrsBits = 12
1998   };
1999
2000   enum SetterKind { Assign, Retain, Copy, Weak };
2001   enum PropertyControl { None, Required, Optional };
2002 private:
2003   SourceLocation AtLoc;   // location of \@property
2004   SourceLocation LParenLoc; // location of '(' starting attribute list or null.
2005   TypeSourceInfo *DeclType;
2006   unsigned PropertyAttributes : NumPropertyAttrsBits;
2007   unsigned PropertyAttributesAsWritten : NumPropertyAttrsBits;
2008   // \@required/\@optional
2009   unsigned PropertyImplementation : 2;
2010
2011   Selector GetterName;    // getter name of NULL if no getter
2012   Selector SetterName;    // setter name of NULL if no setter
2013
2014   ObjCMethodDecl *GetterMethodDecl; // Declaration of getter instance method
2015   ObjCMethodDecl *SetterMethodDecl; // Declaration of setter instance method
2016   ObjCIvarDecl *PropertyIvarDecl;   // Synthesize ivar for this property
2017
2018   ObjCPropertyDecl(DeclContext *DC, SourceLocation L, IdentifierInfo *Id,
2019                    SourceLocation AtLocation,  SourceLocation LParenLocation,
2020                    TypeSourceInfo *T)
2021     : NamedDecl(ObjCProperty, DC, L, Id), AtLoc(AtLocation),
2022       LParenLoc(LParenLocation), DeclType(T),
2023       PropertyAttributes(OBJC_PR_noattr),
2024       PropertyAttributesAsWritten(OBJC_PR_noattr),
2025       PropertyImplementation(None),
2026       GetterName(Selector()),
2027       SetterName(Selector()),
2028       GetterMethodDecl(0), SetterMethodDecl(0) , PropertyIvarDecl(0) {}
2029 public:
2030   static ObjCPropertyDecl *Create(ASTContext &C, DeclContext *DC,
2031                                   SourceLocation L,
2032                                   IdentifierInfo *Id, SourceLocation AtLocation,
2033                                   SourceLocation LParenLocation,
2034                                   TypeSourceInfo *T,
2035                                   PropertyControl propControl = None);
2036
2037   static ObjCPropertyDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2038
2039   SourceLocation getAtLoc() const { return AtLoc; }
2040   void setAtLoc(SourceLocation L) { AtLoc = L; }
2041
2042   SourceLocation getLParenLoc() const { return LParenLoc; }
2043   void setLParenLoc(SourceLocation L) { LParenLoc = L; }
2044
2045   TypeSourceInfo *getTypeSourceInfo() const { return DeclType; }
2046   QualType getType() const { return DeclType->getType(); }
2047   void setType(TypeSourceInfo *T) { DeclType = T; }
2048
2049   PropertyAttributeKind getPropertyAttributes() const {
2050     return PropertyAttributeKind(PropertyAttributes);
2051   }
2052   void setPropertyAttributes(PropertyAttributeKind PRVal) {
2053     PropertyAttributes |= PRVal;
2054   }
2055
2056   PropertyAttributeKind getPropertyAttributesAsWritten() const {
2057     return PropertyAttributeKind(PropertyAttributesAsWritten);
2058   }
2059
2060   bool hasWrittenStorageAttribute() const {
2061     return PropertyAttributesAsWritten & (OBJC_PR_assign | OBJC_PR_copy |
2062         OBJC_PR_unsafe_unretained | OBJC_PR_retain | OBJC_PR_strong |
2063         OBJC_PR_weak);
2064   }
2065
2066   void setPropertyAttributesAsWritten(PropertyAttributeKind PRVal) {
2067     PropertyAttributesAsWritten = PRVal;
2068   }
2069
2070  void makeitReadWriteAttribute() {
2071     PropertyAttributes &= ~OBJC_PR_readonly;
2072     PropertyAttributes |= OBJC_PR_readwrite;
2073  }
2074
2075   // Helper methods for accessing attributes.
2076
2077   /// isReadOnly - Return true iff the property has a setter.
2078   bool isReadOnly() const {
2079     return (PropertyAttributes & OBJC_PR_readonly);
2080   }
2081
2082   /// isAtomic - Return true if the property is atomic.
2083   bool isAtomic() const {
2084     return (PropertyAttributes & OBJC_PR_atomic);
2085   }
2086
2087   /// isRetaining - Return true if the property retains its value.
2088   bool isRetaining() const {
2089     return (PropertyAttributes &
2090             (OBJC_PR_retain | OBJC_PR_strong | OBJC_PR_copy));
2091   }
2092
2093   /// getSetterKind - Return the method used for doing assignment in
2094   /// the property setter. This is only valid if the property has been
2095   /// defined to have a setter.
2096   SetterKind getSetterKind() const {
2097     if (PropertyAttributes & OBJC_PR_strong)
2098       return getType()->isBlockPointerType() ? Copy : Retain;
2099     if (PropertyAttributes & OBJC_PR_retain)
2100       return Retain;
2101     if (PropertyAttributes & OBJC_PR_copy)
2102       return Copy;
2103     if (PropertyAttributes & OBJC_PR_weak)
2104       return Weak;
2105     return Assign;
2106   }
2107
2108   Selector getGetterName() const { return GetterName; }
2109   void setGetterName(Selector Sel) { GetterName = Sel; }
2110
2111   Selector getSetterName() const { return SetterName; }
2112   void setSetterName(Selector Sel) { SetterName = Sel; }
2113
2114   ObjCMethodDecl *getGetterMethodDecl() const { return GetterMethodDecl; }
2115   void setGetterMethodDecl(ObjCMethodDecl *gDecl) { GetterMethodDecl = gDecl; }
2116
2117   ObjCMethodDecl *getSetterMethodDecl() const { return SetterMethodDecl; }
2118   void setSetterMethodDecl(ObjCMethodDecl *gDecl) { SetterMethodDecl = gDecl; }
2119
2120   // Related to \@optional/\@required declared in \@protocol
2121   void setPropertyImplementation(PropertyControl pc) {
2122     PropertyImplementation = pc;
2123   }
2124   PropertyControl getPropertyImplementation() const {
2125     return PropertyControl(PropertyImplementation);
2126   }
2127
2128   void setPropertyIvarDecl(ObjCIvarDecl *Ivar) {
2129     PropertyIvarDecl = Ivar;
2130   }
2131   ObjCIvarDecl *getPropertyIvarDecl() const {
2132     return PropertyIvarDecl;
2133   }
2134
2135   virtual SourceRange getSourceRange() const LLVM_READONLY {
2136     return SourceRange(AtLoc, getLocation());
2137   }
2138
2139   /// Get the default name of the synthesized ivar.
2140   IdentifierInfo *getDefaultSynthIvarName(ASTContext &Ctx) const;
2141
2142   /// Lookup a property by name in the specified DeclContext.
2143   static ObjCPropertyDecl *findPropertyDecl(const DeclContext *DC,
2144                                             IdentifierInfo *propertyID);
2145
2146   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2147   static bool classofKind(Kind K) { return K == ObjCProperty; }
2148 };
2149
2150 /// ObjCPropertyImplDecl - Represents implementation declaration of a property
2151 /// in a class or category implementation block. For example:
2152 /// \@synthesize prop1 = ivar1;
2153 ///
2154 class ObjCPropertyImplDecl : public Decl {
2155 public:
2156   enum Kind {
2157     Synthesize,
2158     Dynamic
2159   };
2160 private:
2161   SourceLocation AtLoc;   // location of \@synthesize or \@dynamic
2162
2163   /// \brief For \@synthesize, the location of the ivar, if it was written in
2164   /// the source code.
2165   ///
2166   /// \code
2167   /// \@synthesize int a = b
2168   /// \endcode
2169   SourceLocation IvarLoc;
2170
2171   /// Property declaration being implemented
2172   ObjCPropertyDecl *PropertyDecl;
2173
2174   /// Null for \@dynamic. Required for \@synthesize.
2175   ObjCIvarDecl *PropertyIvarDecl;
2176
2177   /// Null for \@dynamic. Non-null if property must be copy-constructed in
2178   /// getter.
2179   Expr *GetterCXXConstructor;
2180
2181   /// Null for \@dynamic. Non-null if property has assignment operator to call
2182   /// in Setter synthesis.
2183   Expr *SetterCXXAssignment;
2184
2185   ObjCPropertyImplDecl(DeclContext *DC, SourceLocation atLoc, SourceLocation L,
2186                        ObjCPropertyDecl *property,
2187                        Kind PK,
2188                        ObjCIvarDecl *ivarDecl,
2189                        SourceLocation ivarLoc)
2190     : Decl(ObjCPropertyImpl, DC, L), AtLoc(atLoc),
2191       IvarLoc(ivarLoc), PropertyDecl(property), PropertyIvarDecl(ivarDecl),
2192       GetterCXXConstructor(0), SetterCXXAssignment(0) {
2193     assert (PK == Dynamic || PropertyIvarDecl);
2194   }
2195
2196 public:
2197   static ObjCPropertyImplDecl *Create(ASTContext &C, DeclContext *DC,
2198                                       SourceLocation atLoc, SourceLocation L,
2199                                       ObjCPropertyDecl *property,
2200                                       Kind PK,
2201                                       ObjCIvarDecl *ivarDecl,
2202                                       SourceLocation ivarLoc);
2203
2204   static ObjCPropertyImplDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2205
2206   virtual SourceRange getSourceRange() const LLVM_READONLY;
2207
2208   SourceLocation getLocStart() const LLVM_READONLY { return AtLoc; }
2209   void setAtLoc(SourceLocation Loc) { AtLoc = Loc; }
2210
2211   ObjCPropertyDecl *getPropertyDecl() const {
2212     return PropertyDecl;
2213   }
2214   void setPropertyDecl(ObjCPropertyDecl *Prop) { PropertyDecl = Prop; }
2215
2216   Kind getPropertyImplementation() const {
2217     return PropertyIvarDecl ? Synthesize : Dynamic;
2218   }
2219
2220   ObjCIvarDecl *getPropertyIvarDecl() const {
2221     return PropertyIvarDecl;
2222   }
2223   SourceLocation getPropertyIvarDeclLoc() const { return IvarLoc; }
2224
2225   void setPropertyIvarDecl(ObjCIvarDecl *Ivar,
2226                            SourceLocation IvarLoc) {
2227     PropertyIvarDecl = Ivar;
2228     this->IvarLoc = IvarLoc;
2229   }
2230
2231   /// \brief For \@synthesize, returns true if an ivar name was explicitly
2232   /// specified.
2233   ///
2234   /// \code
2235   /// \@synthesize int a = b; // true
2236   /// \@synthesize int a; // false
2237   /// \endcode
2238   bool isIvarNameSpecified() const {
2239     return IvarLoc.isValid() && IvarLoc != getLocation();
2240   }
2241
2242   Expr *getGetterCXXConstructor() const {
2243     return GetterCXXConstructor;
2244   }
2245   void setGetterCXXConstructor(Expr *getterCXXConstructor) {
2246     GetterCXXConstructor = getterCXXConstructor;
2247   }
2248
2249   Expr *getSetterCXXAssignment() const {
2250     return SetterCXXAssignment;
2251   }
2252   void setSetterCXXAssignment(Expr *setterCXXAssignment) {
2253     SetterCXXAssignment = setterCXXAssignment;
2254   }
2255
2256   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2257   static bool classofKind(Decl::Kind K) { return K == ObjCPropertyImpl; }
2258
2259   friend class ASTDeclReader;
2260 };
2261
2262 template<bool (*Filter)(ObjCCategoryDecl *)>
2263 void
2264 ObjCInterfaceDecl::filtered_category_iterator<Filter>::
2265 findAcceptableCategory() {
2266   while (Current && !Filter(Current))
2267     Current = Current->getNextClassCategoryRaw();
2268 }
2269
2270 template<bool (*Filter)(ObjCCategoryDecl *)>
2271 inline ObjCInterfaceDecl::filtered_category_iterator<Filter> &
2272 ObjCInterfaceDecl::filtered_category_iterator<Filter>::operator++() {
2273   Current = Current->getNextClassCategoryRaw();
2274   findAcceptableCategory();
2275   return *this;
2276 }
2277
2278 inline bool ObjCInterfaceDecl::isVisibleCategory(ObjCCategoryDecl *Cat) {
2279   return !Cat->isHidden();
2280 }
2281
2282 inline bool ObjCInterfaceDecl::isVisibleExtension(ObjCCategoryDecl *Cat) {
2283   return Cat->IsClassExtension() && !Cat->isHidden();
2284 }
2285
2286 inline bool ObjCInterfaceDecl::isKnownExtension(ObjCCategoryDecl *Cat) {
2287   return Cat->IsClassExtension();
2288 }
2289
2290 }  // end namespace clang
2291 #endif