contrib/llvm/tools/clang/lib/AST/DeclObjC.cpp

   1 //===--- DeclObjC.cpp - ObjC Declaration AST Node Implementation ----------===//
   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 implements the Objective-C related Decl classes.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/AST/DeclObjC.h"
  15 #include "clang/AST/ASTContext.h"
  16 #include "clang/AST/Stmt.h"
  17 #include "llvm/ADT/STLExtras.h"
  18 using namespace clang;
  19
  20 //===----------------------------------------------------------------------===//
  21 // ObjCListBase
  22 //===----------------------------------------------------------------------===//
  23
  24 void ObjCListBase::set(void *const* InList, unsigned Elts, ASTContext &Ctx) {
  25   List = 0;
  26   if (Elts == 0) return;  // Setting to an empty list is a noop.
  27
  28
  29   List = new (Ctx) void*[Elts];
  30   NumElts = Elts;
  31   memcpy(List, InList, sizeof(void*)*Elts);
  32 }
  33
  34 void ObjCProtocolList::set(ObjCProtocolDecl* const* InList, unsigned Elts,
  35                            const SourceLocation *Locs, ASTContext &Ctx) {
  36   if (Elts == 0)
  37     return;
  38
  39   Locations = new (Ctx) SourceLocation[Elts];
  40   memcpy(Locations, Locs, sizeof(SourceLocation) * Elts);
  41   set(InList, Elts, Ctx);
  42 }
  43
  44 //===----------------------------------------------------------------------===//
  45 // ObjCInterfaceDecl
  46 //===----------------------------------------------------------------------===//
  47
  48 /// getIvarDecl - This method looks up an ivar in this ContextDecl.
  49 ///
  50 ObjCIvarDecl *
  51 ObjCContainerDecl::getIvarDecl(IdentifierInfo *Id) const {
  52   lookup_const_iterator Ivar, IvarEnd;
  53   for (llvm::tie(Ivar, IvarEnd) = lookup(Id); Ivar != IvarEnd; ++Ivar) {
  54     if (ObjCIvarDecl *ivar = dyn_cast<ObjCIvarDecl>(*Ivar))
  55       return ivar;
  56   }
  57   return 0;
  58 }
  59
  60 // Get the local instance/class method declared in this interface.
  61 ObjCMethodDecl *
  62 ObjCContainerDecl::getMethod(Selector Sel, bool isInstance) const {
  63   // Since instance & class methods can have the same name, the loop below
  64   // ensures we get the correct method.
  65   //
  66   // @interface Whatever
  67   // - (int) class_method;
  68   // + (float) class_method;
  69   // @end
  70   //
  71   lookup_const_iterator Meth, MethEnd;
  72   for (llvm::tie(Meth, MethEnd) = lookup(Sel); Meth != MethEnd; ++Meth) {
  73     ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(*Meth);
  74     if (MD && MD->isInstanceMethod() == isInstance)
  75       return MD;
  76   }
  77   return 0;
  78 }
  79
  80 ObjCPropertyDecl *
  81 ObjCPropertyDecl::findPropertyDecl(const DeclContext *DC,
  82                                    IdentifierInfo *propertyID) {
  83
  84   DeclContext::lookup_const_iterator I, E;
  85   llvm::tie(I, E) = DC->lookup(propertyID);
  86   for ( ; I != E; ++I)
  87     if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(*I))
  88       return PD;
  89
  90   return 0;
  91 }
  92
  93 /// FindPropertyDeclaration - Finds declaration of the property given its name
  94 /// in 'PropertyId' and returns it. It returns 0, if not found.
  95 ObjCPropertyDecl *
  96 ObjCContainerDecl::FindPropertyDeclaration(IdentifierInfo *PropertyId) const {
  97
  98   if (ObjCPropertyDecl *PD =
  99         ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(this), PropertyId))
 100     return PD;
 101
 102   switch (getKind()) {
 103     default:
 104       break;
 105     case Decl::ObjCProtocol: {
 106       const ObjCProtocolDecl *PID = cast<ObjCProtocolDecl>(this);
 107       for (ObjCProtocolDecl::protocol_iterator I = PID->protocol_begin(),
 108            E = PID->protocol_end(); I != E; ++I)
 109         if (ObjCPropertyDecl *P = (*I)->FindPropertyDeclaration(PropertyId))
 110           return P;
 111       break;
 112     }
 113     case Decl::ObjCInterface: {
 114       const ObjCInterfaceDecl *OID = cast<ObjCInterfaceDecl>(this);
 115       // Look through categories.
 116       for (ObjCCategoryDecl *Cat = OID->getCategoryList();
 117            Cat; Cat = Cat->getNextClassCategory())
 118         if (!Cat->IsClassExtension())
 119           if (ObjCPropertyDecl *P = Cat->FindPropertyDeclaration(PropertyId))
 120             return P;
 121
 122       // Look through protocols.
 123       for (ObjCInterfaceDecl::all_protocol_iterator
 124             I = OID->all_referenced_protocol_begin(),
 125             E = OID->all_referenced_protocol_end(); I != E; ++I)
 126         if (ObjCPropertyDecl *P = (*I)->FindPropertyDeclaration(PropertyId))
 127           return P;
 128
 129       // Finally, check the super class.
 130       if (const ObjCInterfaceDecl *superClass = OID->getSuperClass())
 131         return superClass->FindPropertyDeclaration(PropertyId);
 132       break;
 133     }
 134     case Decl::ObjCCategory: {
 135       const ObjCCategoryDecl *OCD = cast<ObjCCategoryDecl>(this);
 136       // Look through protocols.
 137       if (!OCD->IsClassExtension())
 138         for (ObjCCategoryDecl::protocol_iterator
 139               I = OCD->protocol_begin(), E = OCD->protocol_end(); I != E; ++I)
 140         if (ObjCPropertyDecl *P = (*I)->FindPropertyDeclaration(PropertyId))
 141           return P;
 142
 143       break;
 144     }
 145   }
 146   return 0;
 147 }
 148
 149 /// FindPropertyVisibleInPrimaryClass - Finds declaration of the property
 150 /// with name 'PropertyId' in the primary class; including those in protocols
 151 /// (direct or indirect) used by the primary class.
 152 ///
 153 ObjCPropertyDecl *
 154 ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass(
 155                                             IdentifierInfo *PropertyId) const {
 156   if (ExternallyCompleted)
 157     LoadExternalDefinition();
 158
 159   if (ObjCPropertyDecl *PD =
 160       ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(this), PropertyId))
 161     return PD;
 162
 163   // Look through protocols.
 164   for (ObjCInterfaceDecl::all_protocol_iterator
 165         I = all_referenced_protocol_begin(),
 166         E = all_referenced_protocol_end(); I != E; ++I)
 167     if (ObjCPropertyDecl *P = (*I)->FindPropertyDeclaration(PropertyId))
 168       return P;
 169
 170   return 0;
 171 }
 172
 173 void ObjCInterfaceDecl::mergeClassExtensionProtocolList(
 174                               ObjCProtocolDecl *const* ExtList, unsigned ExtNum,
 175                               ASTContext &C)
 176 {
 177   if (ExternallyCompleted)
 178     LoadExternalDefinition();
 179
 180   if (AllReferencedProtocols.empty() && ReferencedProtocols.empty()) {
 181     AllReferencedProtocols.set(ExtList, ExtNum, C);
 182     return;
 183   }
 184
 185   // Check for duplicate protocol in class's protocol list.
 186   // This is O(n*m). But it is extremely rare and number of protocols in
 187   // class or its extension are very few.
 188   llvm::SmallVector<ObjCProtocolDecl*, 8> ProtocolRefs;
 189   for (unsigned i = 0; i < ExtNum; i++) {
 190     bool protocolExists = false;
 191     ObjCProtocolDecl *ProtoInExtension = ExtList[i];
 192     for (all_protocol_iterator
 193           p = all_referenced_protocol_begin(),
 194           e = all_referenced_protocol_end(); p != e; ++p) {
 195       ObjCProtocolDecl *Proto = (*p);
 196       if (C.ProtocolCompatibleWithProtocol(ProtoInExtension, Proto)) {
 197         protocolExists = true;
 198         break;
 199       }
 200     }
 201     // Do we want to warn on a protocol in extension class which
 202     // already exist in the class? Probably not.
 203     if (!protocolExists)
 204       ProtocolRefs.push_back(ProtoInExtension);
 205   }
 206
 207   if (ProtocolRefs.empty())
 208     return;
 209
 210   // Merge ProtocolRefs into class's protocol list;
 211   for (all_protocol_iterator p = all_referenced_protocol_begin(),
 212         e = all_referenced_protocol_end(); p != e; ++p) {
 213     ProtocolRefs.push_back(*p);
 214   }
 215
 216   AllReferencedProtocols.set(ProtocolRefs.data(), ProtocolRefs.size(), C);
 217 }
 218
 219 /// getFirstClassExtension - Find first class extension of the given class.
 220 ObjCCategoryDecl* ObjCInterfaceDecl::getFirstClassExtension() const {
 221   for (ObjCCategoryDecl *CDecl = getCategoryList(); CDecl;
 222        CDecl = CDecl->getNextClassCategory())
 223     if (CDecl->IsClassExtension())
 224       return CDecl;
 225   return 0;
 226 }
 227
 228 /// getNextClassCategory - Find next class extension in list of categories.
 229 const ObjCCategoryDecl* ObjCCategoryDecl::getNextClassExtension() const {
 230   for (const ObjCCategoryDecl *CDecl = getNextClassCategory(); CDecl;
 231         CDecl = CDecl->getNextClassCategory())
 232     if (CDecl->IsClassExtension())
 233       return CDecl;
 234   return 0;
 235 }
 236
 237 ObjCIvarDecl *ObjCInterfaceDecl::lookupInstanceVariable(IdentifierInfo *ID,
 238                                               ObjCInterfaceDecl *&clsDeclared) {
 239   ObjCInterfaceDecl* ClassDecl = this;
 240   while (ClassDecl != NULL) {
 241     if (ObjCIvarDecl *I = ClassDecl->getIvarDecl(ID)) {
 242       clsDeclared = ClassDecl;
 243       return I;
 244     }
 245     for (const ObjCCategoryDecl *CDecl = ClassDecl->getFirstClassExtension();
 246          CDecl; CDecl = CDecl->getNextClassExtension()) {
 247       if (ObjCIvarDecl *I = CDecl->getIvarDecl(ID)) {
 248         clsDeclared = ClassDecl;
 249         return I;
 250       }
 251     }
 252
 253     ClassDecl = ClassDecl->getSuperClass();
 254   }
 255   return NULL;
 256 }
 257
 258 /// lookupInheritedClass - This method returns ObjCInterfaceDecl * of the super
 259 /// class whose name is passed as argument. If it is not one of the super classes
 260 /// the it returns NULL.
 261 ObjCInterfaceDecl *ObjCInterfaceDecl::lookupInheritedClass(
 262                                         const IdentifierInfo*ICName) {
 263   ObjCInterfaceDecl* ClassDecl = this;
 264   while (ClassDecl != NULL) {
 265     if (ClassDecl->getIdentifier() == ICName)
 266       return ClassDecl;
 267     ClassDecl = ClassDecl->getSuperClass();
 268   }
 269   return NULL;
 270 }
 271
 272 /// lookupMethod - This method returns an instance/class method by looking in
 273 /// the class, its categories, and its super classes (using a linear search).
 274 ObjCMethodDecl *ObjCInterfaceDecl::lookupMethod(Selector Sel,
 275                                                 bool isInstance) const {
 276   const ObjCInterfaceDecl* ClassDecl = this;
 277   ObjCMethodDecl *MethodDecl = 0;
 278
 279   if (ExternallyCompleted)
 280     LoadExternalDefinition();
 281
 282   while (ClassDecl != NULL) {
 283     if ((MethodDecl = ClassDecl->getMethod(Sel, isInstance)))
 284       return MethodDecl;
 285
 286     // Didn't find one yet - look through protocols.
 287     const ObjCList<ObjCProtocolDecl> &Protocols =
 288       ClassDecl->getReferencedProtocols();
 289     for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
 290          E = Protocols.end(); I != E; ++I)
 291       if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance)))
 292         return MethodDecl;
 293
 294     // Didn't find one yet - now look through categories.
 295     ObjCCategoryDecl *CatDecl = ClassDecl->getCategoryList();
 296     while (CatDecl) {
 297       if ((MethodDecl = CatDecl->getMethod(Sel, isInstance)))
 298         return MethodDecl;
 299
 300       // Didn't find one yet - look through protocols.
 301       const ObjCList<ObjCProtocolDecl> &Protocols =
 302         CatDecl->getReferencedProtocols();
 303       for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
 304            E = Protocols.end(); I != E; ++I)
 305         if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance)))
 306           return MethodDecl;
 307       CatDecl = CatDecl->getNextClassCategory();
 308     }
 309     ClassDecl = ClassDecl->getSuperClass();
 310   }
 311   return NULL;
 312 }
 313
 314 ObjCMethodDecl *ObjCInterfaceDecl::lookupPrivateMethod(
 315                                    const Selector &Sel,
 316                                    bool Instance) {
 317   ObjCMethodDecl *Method = 0;
 318   if (ObjCImplementationDecl *ImpDecl = getImplementation())
 319     Method = Instance ? ImpDecl->getInstanceMethod(Sel)
 320                       : ImpDecl->getClassMethod(Sel);
 321
 322   if (!Method && getSuperClass())
 323     return getSuperClass()->lookupPrivateMethod(Sel, Instance);
 324   return Method;
 325 }
 326
 327 //===----------------------------------------------------------------------===//
 328 // ObjCMethodDecl
 329 //===----------------------------------------------------------------------===//
 330
 331 ObjCMethodDecl *ObjCMethodDecl::Create(ASTContext &C,
 332                                        SourceLocation beginLoc,
 333                                        SourceLocation endLoc,
 334                                        Selector SelInfo, QualType T,
 335                                        TypeSourceInfo *ResultTInfo,
 336                                        DeclContext *contextDecl,
 337                                        bool isInstance,
 338                                        bool isVariadic,
 339                                        bool isSynthesized,
 340                                        bool isDefined,
 341                                        ImplementationControl impControl,
 342                                        bool HasRelatedResultType,
 343                                        unsigned numSelectorArgs) {
 344   return new (C) ObjCMethodDecl(beginLoc, endLoc,
 345                                 SelInfo, T, ResultTInfo, contextDecl,
 346                                 isInstance,
 347                                 isVariadic, isSynthesized, isDefined,
 348                                 impControl,
 349                                 HasRelatedResultType,
 350                                 numSelectorArgs);
 351 }
 352
 353 /// \brief A definition will return its interface declaration.
 354 /// An interface declaration will return its definition.
 355 /// Otherwise it will return itself.
 356 ObjCMethodDecl *ObjCMethodDecl::getNextRedeclaration() {
 357   ASTContext &Ctx = getASTContext();
 358   ObjCMethodDecl *Redecl = 0;
 359   Decl *CtxD = cast<Decl>(getDeclContext());
 360
 361   if (ObjCInterfaceDecl *IFD = dyn_cast<ObjCInterfaceDecl>(CtxD)) {
 362     if (ObjCImplementationDecl *ImplD = Ctx.getObjCImplementation(IFD))
 363       Redecl = ImplD->getMethod(getSelector(), isInstanceMethod());
 364
 365   } else if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CtxD)) {
 366     if (ObjCCategoryImplDecl *ImplD = Ctx.getObjCImplementation(CD))
 367       Redecl = ImplD->getMethod(getSelector(), isInstanceMethod());
 368
 369   } else if (ObjCImplementationDecl *ImplD =
 370                dyn_cast<ObjCImplementationDecl>(CtxD)) {
 371     if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
 372       Redecl = IFD->getMethod(getSelector(), isInstanceMethod());
 373
 374   } else if (ObjCCategoryImplDecl *CImplD =
 375                dyn_cast<ObjCCategoryImplDecl>(CtxD)) {
 376     if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl())
 377       Redecl = CatD->getMethod(getSelector(), isInstanceMethod());
 378   }
 379
 380   return Redecl ? Redecl : this;
 381 }
 382
 383 ObjCMethodDecl *ObjCMethodDecl::getCanonicalDecl() {
 384   Decl *CtxD = cast<Decl>(getDeclContext());
 385
 386   if (ObjCImplementationDecl *ImplD = dyn_cast<ObjCImplementationDecl>(CtxD)) {
 387     if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
 388       if (ObjCMethodDecl *MD = IFD->getMethod(getSelector(),
 389                                               isInstanceMethod()))
 390         return MD;
 391
 392   } else if (ObjCCategoryImplDecl *CImplD =
 393                dyn_cast<ObjCCategoryImplDecl>(CtxD)) {
 394     if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl())
 395       if (ObjCMethodDecl *MD = CatD->getMethod(getSelector(),
 396                                                isInstanceMethod()))
 397         return MD;
 398   }
 399
 400   return this;
 401 }
 402
 403 ObjCMethodFamily ObjCMethodDecl::getMethodFamily() const {
 404   ObjCMethodFamily family = static_cast<ObjCMethodFamily>(Family);
 405   if (family != static_cast<unsigned>(InvalidObjCMethodFamily))
 406     return family;
 407
 408   // Check for an explicit attribute.
 409   if (const ObjCMethodFamilyAttr *attr = getAttr<ObjCMethodFamilyAttr>()) {
 410     // The unfortunate necessity of mapping between enums here is due
 411     // to the attributes framework.
 412     switch (attr->getFamily()) {
 413     case ObjCMethodFamilyAttr::OMF_None: family = OMF_None; break;
 414     case ObjCMethodFamilyAttr::OMF_alloc: family = OMF_alloc; break;
 415     case ObjCMethodFamilyAttr::OMF_copy: family = OMF_copy; break;
 416     case ObjCMethodFamilyAttr::OMF_init: family = OMF_init; break;
 417     case ObjCMethodFamilyAttr::OMF_mutableCopy: family = OMF_mutableCopy; break;
 418     case ObjCMethodFamilyAttr::OMF_new: family = OMF_new; break;
 419     }
 420     Family = static_cast<unsigned>(family);
 421     return family;
 422   }
 423
 424   family = getSelector().getMethodFamily();
 425   switch (family) {
 426   case OMF_None: break;
 427
 428   // init only has a conventional meaning for an instance method, and
 429   // it has to return an object.
 430   case OMF_init:
 431     if (!isInstanceMethod() || !getResultType()->isObjCObjectPointerType())
 432       family = OMF_None;
 433     break;
 434
 435   // alloc/copy/new have a conventional meaning for both class and
 436   // instance methods, but they require an object return.
 437   case OMF_alloc:
 438   case OMF_copy:
 439   case OMF_mutableCopy:
 440   case OMF_new:
 441     if (!getResultType()->isObjCObjectPointerType())
 442       family = OMF_None;
 443     break;
 444
 445   // These selectors have a conventional meaning only for instance methods.
 446   case OMF_dealloc:
 447   case OMF_retain:
 448   case OMF_release:
 449   case OMF_autorelease:
 450   case OMF_retainCount:
 451   case OMF_self:
 452     if (!isInstanceMethod())
 453       family = OMF_None;
 454     break;
 455   }
 456
 457   // Cache the result.
 458   Family = static_cast<unsigned>(family);
 459   return family;
 460 }
 461
 462 void ObjCMethodDecl::createImplicitParams(ASTContext &Context,
 463                                           const ObjCInterfaceDecl *OID) {
 464   QualType selfTy;
 465   if (isInstanceMethod()) {
 466     // There may be no interface context due to error in declaration
 467     // of the interface (which has been reported). Recover gracefully.
 468     if (OID) {
 469       selfTy = Context.getObjCInterfaceType(OID);
 470       selfTy = Context.getObjCObjectPointerType(selfTy);
 471     } else {
 472       selfTy = Context.getObjCIdType();
 473     }
 474   } else // we have a factory method.
 475     selfTy = Context.getObjCClassType();
 476
 477   setSelfDecl(ImplicitParamDecl::Create(Context, this, SourceLocation(),
 478                                         &Context.Idents.get("self"), selfTy));
 479
 480   setCmdDecl(ImplicitParamDecl::Create(Context, this, SourceLocation(),
 481                                        &Context.Idents.get("_cmd"),
 482                                        Context.getObjCSelType()));
 483 }
 484
 485 ObjCInterfaceDecl *ObjCMethodDecl::getClassInterface() {
 486   if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(getDeclContext()))
 487     return ID;
 488   if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(getDeclContext()))
 489     return CD->getClassInterface();
 490   if (ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(getDeclContext()))
 491     return IMD->getClassInterface();
 492
 493   assert(!isa<ObjCProtocolDecl>(getDeclContext()) && "It's a protocol method");
 494   assert(false && "unknown method context");
 495   return 0;
 496 }
 497
 498 //===----------------------------------------------------------------------===//
 499 // ObjCInterfaceDecl
 500 //===----------------------------------------------------------------------===//
 501
 502 ObjCInterfaceDecl *ObjCInterfaceDecl::Create(ASTContext &C,
 503                                              DeclContext *DC,
 504                                              SourceLocation atLoc,
 505                                              IdentifierInfo *Id,
 506                                              SourceLocation ClassLoc,
 507                                              bool ForwardDecl, bool isInternal){
 508   return new (C) ObjCInterfaceDecl(DC, atLoc, Id, ClassLoc, ForwardDecl,
 509                                      isInternal);
 510 }
 511
 512 ObjCInterfaceDecl::
 513 ObjCInterfaceDecl(DeclContext *DC, SourceLocation atLoc, IdentifierInfo *Id,
 514                   SourceLocation CLoc, bool FD, bool isInternal)
 515   : ObjCContainerDecl(ObjCInterface, DC, atLoc, Id),
 516     TypeForDecl(0), SuperClass(0),
 517     CategoryList(0), IvarList(0),
 518     ForwardDecl(FD), InternalInterface(isInternal), ExternallyCompleted(false),
 519     ClassLoc(CLoc) {
 520 }
 521
 522 void ObjCInterfaceDecl::LoadExternalDefinition() const {
 523   assert(ExternallyCompleted && "Class is not externally completed");
 524   ExternallyCompleted = false;
 525   getASTContext().getExternalSource()->CompleteType(
 526                                         const_cast<ObjCInterfaceDecl *>(this));
 527 }
 528
 529 void ObjCInterfaceDecl::setExternallyCompleted() {
 530   assert(getASTContext().getExternalSource() &&
 531          "Class can't be externally completed without an external source");
 532   assert(!ForwardDecl &&
 533          "Forward declarations can't be externally completed");
 534   ExternallyCompleted = true;
 535 }
 536
 537 ObjCImplementationDecl *ObjCInterfaceDecl::getImplementation() const {
 538   if (ExternallyCompleted)
 539     LoadExternalDefinition();
 540
 541   return getASTContext().getObjCImplementation(
 542                                           const_cast<ObjCInterfaceDecl*>(this));
 543 }
 544
 545 void ObjCInterfaceDecl::setImplementation(ObjCImplementationDecl *ImplD) {
 546   getASTContext().setObjCImplementation(this, ImplD);
 547 }
 548
 549 /// all_declared_ivar_begin - return first ivar declared in this class,
 550 /// its extensions and its implementation. Lazily build the list on first
 551 /// access.
 552 ObjCIvarDecl *ObjCInterfaceDecl::all_declared_ivar_begin() {
 553   if (IvarList)
 554     return IvarList;
 555
 556   ObjCIvarDecl *curIvar = 0;
 557   if (!ivar_empty()) {
 558     ObjCInterfaceDecl::ivar_iterator I = ivar_begin(), E = ivar_end();
 559     IvarList = (*I); ++I;
 560     for (curIvar = IvarList; I != E; curIvar = *I, ++I)
 561       curIvar->setNextIvar(*I);
 562   }
 563
 564   for (const ObjCCategoryDecl *CDecl = getFirstClassExtension(); CDecl;
 565        CDecl = CDecl->getNextClassExtension()) {
 566     if (!CDecl->ivar_empty()) {
 567       ObjCCategoryDecl::ivar_iterator I = CDecl->ivar_begin(),
 568                                           E = CDecl->ivar_end();
 569       if (!IvarList) {
 570         IvarList = (*I); ++I;
 571         curIvar = IvarList;
 572       }
 573       for ( ;I != E; curIvar = *I, ++I)
 574         curIvar->setNextIvar(*I);
 575     }
 576   }
 577
 578   if (ObjCImplementationDecl *ImplDecl = getImplementation()) {
 579     if (!ImplDecl->ivar_empty()) {
 580       ObjCImplementationDecl::ivar_iterator I = ImplDecl->ivar_begin(),
 581                                             E = ImplDecl->ivar_end();
 582       if (!IvarList) {
 583         IvarList = (*I); ++I;
 584         curIvar = IvarList;
 585       }
 586       for ( ;I != E; curIvar = *I, ++I)
 587         curIvar->setNextIvar(*I);
 588     }
 589   }
 590   return IvarList;
 591 }
 592
 593 /// FindCategoryDeclaration - Finds category declaration in the list of
 594 /// categories for this class and returns it. Name of the category is passed
 595 /// in 'CategoryId'. If category not found, return 0;
 596 ///
 597 ObjCCategoryDecl *
 598 ObjCInterfaceDecl::FindCategoryDeclaration(IdentifierInfo *CategoryId) const {
 599   if (ExternallyCompleted)
 600     LoadExternalDefinition();
 601
 602   for (ObjCCategoryDecl *Category = getCategoryList();
 603        Category; Category = Category->getNextClassCategory())
 604     if (Category->getIdentifier() == CategoryId)
 605       return Category;
 606   return 0;
 607 }
 608
 609 ObjCMethodDecl *
 610 ObjCInterfaceDecl::getCategoryInstanceMethod(Selector Sel) const {
 611   for (ObjCCategoryDecl *Category = getCategoryList();
 612        Category; Category = Category->getNextClassCategory())
 613     if (ObjCCategoryImplDecl *Impl = Category->getImplementation())
 614       if (ObjCMethodDecl *MD = Impl->getInstanceMethod(Sel))
 615         return MD;
 616   return 0;
 617 }
 618
 619 ObjCMethodDecl *ObjCInterfaceDecl::getCategoryClassMethod(Selector Sel) const {
 620   for (ObjCCategoryDecl *Category = getCategoryList();
 621        Category; Category = Category->getNextClassCategory())
 622     if (ObjCCategoryImplDecl *Impl = Category->getImplementation())
 623       if (ObjCMethodDecl *MD = Impl->getClassMethod(Sel))
 624         return MD;
 625   return 0;
 626 }
 627
 628 /// ClassImplementsProtocol - Checks that 'lProto' protocol
 629 /// has been implemented in IDecl class, its super class or categories (if
 630 /// lookupCategory is true).
 631 bool ObjCInterfaceDecl::ClassImplementsProtocol(ObjCProtocolDecl *lProto,
 632                                     bool lookupCategory,
 633                                     bool RHSIsQualifiedID) {
 634   ObjCInterfaceDecl *IDecl = this;
 635   // 1st, look up the class.
 636   const ObjCList<ObjCProtocolDecl> &Protocols =
 637   IDecl->getReferencedProtocols();
 638
 639   for (ObjCList<ObjCProtocolDecl>::iterator PI = Protocols.begin(),
 640        E = Protocols.end(); PI != E; ++PI) {
 641     if (getASTContext().ProtocolCompatibleWithProtocol(lProto, *PI))
 642       return true;
 643     // This is dubious and is added to be compatible with gcc.  In gcc, it is
 644     // also allowed assigning a protocol-qualified 'id' type to a LHS object
 645     // when protocol in qualified LHS is in list of protocols in the rhs 'id'
 646     // object. This IMO, should be a bug.
 647     // FIXME: Treat this as an extension, and flag this as an error when GCC
 648     // extensions are not enabled.
 649     if (RHSIsQualifiedID &&
 650         getASTContext().ProtocolCompatibleWithProtocol(*PI, lProto))
 651       return true;
 652   }
 653
 654   // 2nd, look up the category.
 655   if (lookupCategory)
 656     for (ObjCCategoryDecl *CDecl = IDecl->getCategoryList(); CDecl;
 657          CDecl = CDecl->getNextClassCategory()) {
 658       for (ObjCCategoryDecl::protocol_iterator PI = CDecl->protocol_begin(),
 659            E = CDecl->protocol_end(); PI != E; ++PI)
 660         if (getASTContext().ProtocolCompatibleWithProtocol(lProto, *PI))
 661           return true;
 662     }
 663
 664   // 3rd, look up the super class(s)
 665   if (IDecl->getSuperClass())
 666     return
 667   IDecl->getSuperClass()->ClassImplementsProtocol(lProto, lookupCategory,
 668                                                   RHSIsQualifiedID);
 669
 670   return false;
 671 }
 672
 673 //===----------------------------------------------------------------------===//
 674 // ObjCIvarDecl
 675 //===----------------------------------------------------------------------===//
 676
 677 ObjCIvarDecl *ObjCIvarDecl::Create(ASTContext &C, ObjCContainerDecl *DC,
 678                                    SourceLocation StartLoc,
 679                                    SourceLocation IdLoc, IdentifierInfo *Id,
 680                                    QualType T, TypeSourceInfo *TInfo,
 681                                    AccessControl ac, Expr *BW,
 682                                    bool synthesized) {
 683   if (DC) {
 684     // Ivar's can only appear in interfaces, implementations (via synthesized
 685     // properties), and class extensions (via direct declaration, or synthesized
 686     // properties).
 687     //
 688     // FIXME: This should really be asserting this:
 689     //   (isa<ObjCCategoryDecl>(DC) &&
 690     //    cast<ObjCCategoryDecl>(DC)->IsClassExtension()))
 691     // but unfortunately we sometimes place ivars into non-class extension
 692     // categories on error. This breaks an AST invariant, and should not be
 693     // fixed.
 694     assert((isa<ObjCInterfaceDecl>(DC) || isa<ObjCImplementationDecl>(DC) ||
 695             isa<ObjCCategoryDecl>(DC)) &&
 696            "Invalid ivar decl context!");
 697     // Once a new ivar is created in any of class/class-extension/implementation
 698     // decl contexts, the previously built IvarList must be rebuilt.
 699     ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(DC);
 700     if (!ID) {
 701       if (ObjCImplementationDecl *IM = dyn_cast<ObjCImplementationDecl>(DC)) {
 702         ID = IM->getClassInterface();
 703         if (BW)
 704           IM->setHasSynthBitfield(true);
 705       }
 706       else {
 707         ObjCCategoryDecl *CD = cast<ObjCCategoryDecl>(DC);
 708         ID = CD->getClassInterface();
 709         if (BW)
 710           CD->setHasSynthBitfield(true);
 711       }
 712     }
 713     ID->setIvarList(0);
 714   }
 715
 716   return new (C) ObjCIvarDecl(DC, StartLoc, IdLoc, Id, T, TInfo,
 717                               ac, BW, synthesized);
 718 }
 719
 720 const ObjCInterfaceDecl *ObjCIvarDecl::getContainingInterface() const {
 721   const ObjCContainerDecl *DC = cast<ObjCContainerDecl>(getDeclContext());
 722
 723   switch (DC->getKind()) {
 724   default:
 725   case ObjCCategoryImpl:
 726   case ObjCProtocol:
 727     assert(0 && "invalid ivar container!");
 728     return 0;
 729
 730     // Ivars can only appear in class extension categories.
 731   case ObjCCategory: {
 732     const ObjCCategoryDecl *CD = cast<ObjCCategoryDecl>(DC);
 733     assert(CD->IsClassExtension() && "invalid container for ivar!");
 734     return CD->getClassInterface();
 735   }
 736
 737   case ObjCImplementation:
 738     return cast<ObjCImplementationDecl>(DC)->getClassInterface();
 739
 740   case ObjCInterface:
 741     return cast<ObjCInterfaceDecl>(DC);
 742   }
 743 }
 744
 745 //===----------------------------------------------------------------------===//
 746 // ObjCAtDefsFieldDecl
 747 //===----------------------------------------------------------------------===//
 748
 749 ObjCAtDefsFieldDecl
 750 *ObjCAtDefsFieldDecl::Create(ASTContext &C, DeclContext *DC,
 751                              SourceLocation StartLoc,  SourceLocation IdLoc,
 752                              IdentifierInfo *Id, QualType T, Expr *BW) {
 753   return new (C) ObjCAtDefsFieldDecl(DC, StartLoc, IdLoc, Id, T, BW);
 754 }
 755
 756 //===----------------------------------------------------------------------===//
 757 // ObjCProtocolDecl
 758 //===----------------------------------------------------------------------===//
 759
 760 ObjCProtocolDecl *ObjCProtocolDecl::Create(ASTContext &C, DeclContext *DC,
 761                                            SourceLocation L,
 762                                            IdentifierInfo *Id) {
 763   return new (C) ObjCProtocolDecl(DC, L, Id);
 764 }
 765
 766 ObjCProtocolDecl *ObjCProtocolDecl::lookupProtocolNamed(IdentifierInfo *Name) {
 767   ObjCProtocolDecl *PDecl = this;
 768
 769   if (Name == getIdentifier())
 770     return PDecl;
 771
 772   for (protocol_iterator I = protocol_begin(), E = protocol_end(); I != E; ++I)
 773     if ((PDecl = (*I)->lookupProtocolNamed(Name)))
 774       return PDecl;
 775
 776   return NULL;
 777 }
 778
 779 // lookupMethod - Lookup a instance/class method in the protocol and protocols
 780 // it inherited.
 781 ObjCMethodDecl *ObjCProtocolDecl::lookupMethod(Selector Sel,
 782                                                bool isInstance) const {
 783   ObjCMethodDecl *MethodDecl = NULL;
 784
 785   if ((MethodDecl = getMethod(Sel, isInstance)))
 786     return MethodDecl;
 787
 788   for (protocol_iterator I = protocol_begin(), E = protocol_end(); I != E; ++I)
 789     if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance)))
 790       return MethodDecl;
 791   return NULL;
 792 }
 793
 794 //===----------------------------------------------------------------------===//
 795 // ObjCClassDecl
 796 //===----------------------------------------------------------------------===//
 797
 798 ObjCClassDecl::ObjCClassDecl(DeclContext *DC, SourceLocation L,
 799                              ObjCInterfaceDecl *const *Elts,
 800                              const SourceLocation *Locs,
 801                              unsigned nElts,
 802                              ASTContext &C)
 803   : Decl(ObjCClass, DC, L) {
 804   setClassList(C, Elts, Locs, nElts);
 805 }
 806
 807 void ObjCClassDecl::setClassList(ASTContext &C, ObjCInterfaceDecl*const*List,
 808                                  const SourceLocation *Locs, unsigned Num) {
 809   ForwardDecls = (ObjCClassRef*) C.Allocate(sizeof(ObjCClassRef)*Num,
 810                                             llvm::alignOf<ObjCClassRef>());
 811   for (unsigned i = 0; i < Num; ++i)
 812     new (&ForwardDecls[i]) ObjCClassRef(List[i], Locs[i]);
 813
 814   NumDecls = Num;
 815 }
 816
 817 ObjCClassDecl *ObjCClassDecl::Create(ASTContext &C, DeclContext *DC,
 818                                      SourceLocation L,
 819                                      ObjCInterfaceDecl *const *Elts,
 820                                      const SourceLocation *Locs,
 821                                      unsigned nElts) {
 822   return new (C) ObjCClassDecl(DC, L, Elts, Locs, nElts, C);
 823 }
 824
 825 SourceRange ObjCClassDecl::getSourceRange() const {
 826   // FIXME: We should include the semicolon
 827   assert(NumDecls);
 828   return SourceRange(getLocation(), ForwardDecls[NumDecls-1].getLocation());
 829 }
 830
 831 //===----------------------------------------------------------------------===//
 832 // ObjCForwardProtocolDecl
 833 //===----------------------------------------------------------------------===//
 834
 835 ObjCForwardProtocolDecl::
 836 ObjCForwardProtocolDecl(DeclContext *DC, SourceLocation L,
 837                         ObjCProtocolDecl *const *Elts, unsigned nElts,
 838                         const SourceLocation *Locs, ASTContext &C)
 839 : Decl(ObjCForwardProtocol, DC, L) {
 840   ReferencedProtocols.set(Elts, nElts, Locs, C);
 841 }
 842
 843
 844 ObjCForwardProtocolDecl *
 845 ObjCForwardProtocolDecl::Create(ASTContext &C, DeclContext *DC,
 846                                 SourceLocation L,
 847                                 ObjCProtocolDecl *const *Elts,
 848                                 unsigned NumElts,
 849                                 const SourceLocation *Locs) {
 850   return new (C) ObjCForwardProtocolDecl(DC, L, Elts, NumElts, Locs, C);
 851 }
 852
 853 //===----------------------------------------------------------------------===//
 854 // ObjCCategoryDecl
 855 //===----------------------------------------------------------------------===//
 856
 857 ObjCCategoryDecl *ObjCCategoryDecl::Create(ASTContext &C, DeclContext *DC,
 858                                            SourceLocation AtLoc,
 859                                            SourceLocation ClassNameLoc,
 860                                            SourceLocation CategoryNameLoc,
 861                                            IdentifierInfo *Id) {
 862   return new (C) ObjCCategoryDecl(DC, AtLoc, ClassNameLoc, CategoryNameLoc, Id);
 863 }
 864
 865 ObjCCategoryImplDecl *ObjCCategoryDecl::getImplementation() const {
 866   return getASTContext().getObjCImplementation(
 867                                            const_cast<ObjCCategoryDecl*>(this));
 868 }
 869
 870 void ObjCCategoryDecl::setImplementation(ObjCCategoryImplDecl *ImplD) {
 871   getASTContext().setObjCImplementation(this, ImplD);
 872 }
 873
 874
 875 //===----------------------------------------------------------------------===//
 876 // ObjCCategoryImplDecl
 877 //===----------------------------------------------------------------------===//
 878
 879 ObjCCategoryImplDecl *
 880 ObjCCategoryImplDecl::Create(ASTContext &C, DeclContext *DC,
 881                              SourceLocation L,IdentifierInfo *Id,
 882                              ObjCInterfaceDecl *ClassInterface) {
 883   return new (C) ObjCCategoryImplDecl(DC, L, Id, ClassInterface);
 884 }
 885
 886 ObjCCategoryDecl *ObjCCategoryImplDecl::getCategoryDecl() const {
 887   // The class interface might be NULL if we are working with invalid code.
 888   if (const ObjCInterfaceDecl *ID = getClassInterface())
 889     return ID->FindCategoryDeclaration(getIdentifier());
 890   return 0;
 891 }
 892
 893
 894 void ObjCImplDecl::addPropertyImplementation(ObjCPropertyImplDecl *property) {
 895   // FIXME: The context should be correct before we get here.
 896   property->setLexicalDeclContext(this);
 897   addDecl(property);
 898 }
 899
 900 void ObjCImplDecl::setClassInterface(ObjCInterfaceDecl *IFace) {
 901   ASTContext &Ctx = getASTContext();
 902
 903   if (ObjCImplementationDecl *ImplD
 904         = dyn_cast_or_null<ObjCImplementationDecl>(this)) {
 905     if (IFace)
 906       Ctx.setObjCImplementation(IFace, ImplD);
 907
 908   } else if (ObjCCategoryImplDecl *ImplD =
 909              dyn_cast_or_null<ObjCCategoryImplDecl>(this)) {
 910     if (ObjCCategoryDecl *CD = IFace->FindCategoryDeclaration(getIdentifier()))
 911       Ctx.setObjCImplementation(CD, ImplD);
 912   }
 913
 914   ClassInterface = IFace;
 915 }
 916
 917 /// FindPropertyImplIvarDecl - This method lookup the ivar in the list of
 918 /// properties implemented in this category @implementation block and returns
 919 /// the implemented property that uses it.
 920 ///
 921 ObjCPropertyImplDecl *ObjCImplDecl::
 922 FindPropertyImplIvarDecl(IdentifierInfo *ivarId) const {
 923   for (propimpl_iterator i = propimpl_begin(), e = propimpl_end(); i != e; ++i){
 924     ObjCPropertyImplDecl *PID = *i;
 925     if (PID->getPropertyIvarDecl() &&
 926         PID->getPropertyIvarDecl()->getIdentifier() == ivarId)
 927       return PID;
 928   }
 929   return 0;
 930 }
 931
 932 /// FindPropertyImplDecl - This method looks up a previous ObjCPropertyImplDecl
 933 /// added to the list of those properties @synthesized/@dynamic in this
 934 /// category @implementation block.
 935 ///
 936 ObjCPropertyImplDecl *ObjCImplDecl::
 937 FindPropertyImplDecl(IdentifierInfo *Id) const {
 938   for (propimpl_iterator i = propimpl_begin(), e = propimpl_end(); i != e; ++i){
 939     ObjCPropertyImplDecl *PID = *i;
 940     if (PID->getPropertyDecl()->getIdentifier() == Id)
 941       return PID;
 942   }
 943   return 0;
 944 }
 945
 946 llvm::raw_ostream &clang::operator<<(llvm::raw_ostream &OS,
 947                                      const ObjCCategoryImplDecl *CID) {
 948   OS << CID->getName();
 949   return OS;
 950 }
 951
 952 //===----------------------------------------------------------------------===//
 953 // ObjCImplementationDecl
 954 //===----------------------------------------------------------------------===//
 955
 956 ObjCImplementationDecl *
 957 ObjCImplementationDecl::Create(ASTContext &C, DeclContext *DC,
 958                                SourceLocation L,
 959                                ObjCInterfaceDecl *ClassInterface,
 960                                ObjCInterfaceDecl *SuperDecl) {
 961   return new (C) ObjCImplementationDecl(DC, L, ClassInterface, SuperDecl);
 962 }
 963
 964 llvm::raw_ostream &clang::operator<<(llvm::raw_ostream &OS,
 965                                      const ObjCImplementationDecl *ID) {
 966   OS << ID->getName();
 967   return OS;
 968 }
 969
 970 //===----------------------------------------------------------------------===//
 971 // ObjCCompatibleAliasDecl
 972 //===----------------------------------------------------------------------===//
 973
 974 ObjCCompatibleAliasDecl *
 975 ObjCCompatibleAliasDecl::Create(ASTContext &C, DeclContext *DC,
 976                                 SourceLocation L,
 977                                 IdentifierInfo *Id,
 978                                 ObjCInterfaceDecl* AliasedClass) {
 979   return new (C) ObjCCompatibleAliasDecl(DC, L, Id, AliasedClass);
 980 }
 981
 982 //===----------------------------------------------------------------------===//
 983 // ObjCPropertyDecl
 984 //===----------------------------------------------------------------------===//
 985
 986 ObjCPropertyDecl *ObjCPropertyDecl::Create(ASTContext &C, DeclContext *DC,
 987                                            SourceLocation L,
 988                                            IdentifierInfo *Id,
 989                                            SourceLocation AtLoc,
 990                                            TypeSourceInfo *T,
 991                                            PropertyControl propControl) {
 992   return new (C) ObjCPropertyDecl(DC, L, Id, AtLoc, T);
 993 }
 994
 995 //===----------------------------------------------------------------------===//
 996 // ObjCPropertyImplDecl
 997 //===----------------------------------------------------------------------===//
 998
 999 ObjCPropertyImplDecl *ObjCPropertyImplDecl::Create(ASTContext &C,
1000                                                    DeclContext *DC,
1001                                                    SourceLocation atLoc,
1002                                                    SourceLocation L,
1003                                                    ObjCPropertyDecl *property,
1004                                                    Kind PK,
1005                                                    ObjCIvarDecl *ivar,
1006                                                    SourceLocation ivarLoc) {
1007   return new (C) ObjCPropertyImplDecl(DC, atLoc, L, property, PK, ivar,
1008                                       ivarLoc);
1009 }
1010
1011 SourceRange ObjCPropertyImplDecl::getSourceRange() const {
1012   SourceLocation EndLoc = getLocation();
1013   if (IvarLoc.isValid())
1014     EndLoc = IvarLoc;
1015
1016   return SourceRange(AtLoc, EndLoc);
1017 }