Home | History | Annotate | Download | only in AST 
      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 "clang/AST/ASTMutationListener.h"
     18 #include "llvm/ADT/STLExtras.h"
     19 using namespace clang;
     20 
     21 //===----------------------------------------------------------------------===//
     22 // ObjCListBase
     23 //===----------------------------------------------------------------------===//
     24 
     25 void ObjCListBase::set(void *const* InList, unsigned Elts, ASTContext &Ctx) {
     26   List = 0;
     27   if (Elts == 0) return;  // Setting to an empty list is a noop.
     28 
     29 
     30   List = new (Ctx) void*[Elts];
     31   NumElts = Elts;
     32   memcpy(List, InList, sizeof(void*)*Elts);
     33 }
     34 
     35 void ObjCProtocolList::set(ObjCProtocolDecl* const* InList, unsigned Elts,
     36                            const SourceLocation *Locs, ASTContext &Ctx) {
     37   if (Elts == 0)
     38     return;
     39 
     40   Locations = new (Ctx) SourceLocation[Elts];
     41   memcpy(Locations, Locs, sizeof(SourceLocation) * Elts);
     42   set(InList, Elts, Ctx);
     43 }
     44 
     45 //===----------------------------------------------------------------------===//
     46 // ObjCInterfaceDecl
     47 //===----------------------------------------------------------------------===//
     48 
     49 void ObjCContainerDecl::anchor() { }
     50 
     51 /// getIvarDecl - This method looks up an ivar in this ContextDecl.
     52 ///
     53 ObjCIvarDecl *
     54 ObjCContainerDecl::getIvarDecl(IdentifierInfo *Id) const {
     55   lookup_const_iterator Ivar, IvarEnd;
     56   for (llvm::tie(Ivar, IvarEnd) = lookup(Id); Ivar != IvarEnd; ++Ivar) {
     57     if (ObjCIvarDecl *ivar = dyn_cast<ObjCIvarDecl>(*Ivar))
     58       return ivar;
     59   }
     60   return 0;
     61 }
     62 
     63 // Get the local instance/class method declared in this interface.
     64 ObjCMethodDecl *
     65 ObjCContainerDecl::getMethod(Selector Sel, bool isInstance) const {
     66   // Since instance & class methods can have the same name, the loop below
     67   // ensures we get the correct method.
     68   //
     69   // @interface Whatever
     70   // - (int) class_method;
     71   // + (float) class_method;
     72   // @end
     73   //
     74   lookup_const_iterator Meth, MethEnd;
     75   for (llvm::tie(Meth, MethEnd) = lookup(Sel); Meth != MethEnd; ++Meth) {
     76     ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(*Meth);
     77     if (MD && MD->isInstanceMethod() == isInstance)
     78       return MD;
     79   }
     80   return 0;
     81 }
     82 
     83 ObjCPropertyDecl *
     84 ObjCPropertyDecl::findPropertyDecl(const DeclContext *DC,
     85                                    IdentifierInfo *propertyID) {
     86 
     87   DeclContext::lookup_const_iterator I, E;
     88   llvm::tie(I, E) = DC->lookup(propertyID);
     89   for ( ; I != E; ++I)
     90     if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(*I))
     91       return PD;
     92 
     93   return 0;
     94 }
     95 
     96 /// FindPropertyDeclaration - Finds declaration of the property given its name
     97 /// in 'PropertyId' and returns it. It returns 0, if not found.
     98 ObjCPropertyDecl *
     99 ObjCContainerDecl::FindPropertyDeclaration(IdentifierInfo *PropertyId) const {
    100 
    101   if (ObjCPropertyDecl *PD =
    102         ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(this), PropertyId))
    103     return PD;
    104 
    105   switch (getKind()) {
    106     default:
    107       break;
    108     case Decl::ObjCProtocol: {
    109       const ObjCProtocolDecl *PID = cast<ObjCProtocolDecl>(this);
    110       for (ObjCProtocolDecl::protocol_iterator I = PID->protocol_begin(),
    111            E = PID->protocol_end(); I != E; ++I)
    112         if (ObjCPropertyDecl *P = (*I)->FindPropertyDeclaration(PropertyId))
    113           return P;
    114       break;
    115     }
    116     case Decl::ObjCInterface: {
    117       const ObjCInterfaceDecl *OID = cast<ObjCInterfaceDecl>(this);
    118       // Look through categories.
    119       for (ObjCCategoryDecl *Cat = OID->getCategoryList();
    120            Cat; Cat = Cat->getNextClassCategory())
    121         if (!Cat->IsClassExtension())
    122           if (ObjCPropertyDecl *P = Cat->FindPropertyDeclaration(PropertyId))
    123             return P;
    124 
    125       // Look through protocols.
    126       for (ObjCInterfaceDecl::all_protocol_iterator
    127             I = OID->all_referenced_protocol_begin(),
    128             E = OID->all_referenced_protocol_end(); I != E; ++I)
    129         if (ObjCPropertyDecl *P = (*I)->FindPropertyDeclaration(PropertyId))
    130           return P;
    131 
    132       // Finally, check the super class.
    133       if (const ObjCInterfaceDecl *superClass = OID->getSuperClass())
    134         return superClass->FindPropertyDeclaration(PropertyId);
    135       break;
    136     }
    137     case Decl::ObjCCategory: {
    138       const ObjCCategoryDecl *OCD = cast<ObjCCategoryDecl>(this);
    139       // Look through protocols.
    140       if (!OCD->IsClassExtension())
    141         for (ObjCCategoryDecl::protocol_iterator
    142               I = OCD->protocol_begin(), E = OCD->protocol_end(); I != E; ++I)
    143         if (ObjCPropertyDecl *P = (*I)->FindPropertyDeclaration(PropertyId))
    144           return P;
    145 
    146       break;
    147     }
    148   }
    149   return 0;
    150 }
    151 
    152 void ObjCInterfaceDecl::anchor() { }
    153 
    154 /// FindPropertyVisibleInPrimaryClass - Finds declaration of the property
    155 /// with name 'PropertyId' in the primary class; including those in protocols
    156 /// (direct or indirect) used by the primary class.
    157 ///
    158 ObjCPropertyDecl *
    159 ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass(
    160                                             IdentifierInfo *PropertyId) const {
    161   // FIXME: Should make sure no callers ever do this.
    162   if (!hasDefinition())
    163     return 0;
    164 
    165   if (data().ExternallyCompleted)
    166     LoadExternalDefinition();
    167 
    168   if (ObjCPropertyDecl *PD =
    169       ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(this), PropertyId))
    170     return PD;
    171 
    172   // Look through protocols.
    173   for (ObjCInterfaceDecl::all_protocol_iterator
    174         I = all_referenced_protocol_begin(),
    175         E = all_referenced_protocol_end(); I != E; ++I)
    176     if (ObjCPropertyDecl *P = (*I)->FindPropertyDeclaration(PropertyId))
    177       return P;
    178 
    179   return 0;
    180 }
    181 
    182 void ObjCInterfaceDecl::mergeClassExtensionProtocolList(
    183                               ObjCProtocolDecl *const* ExtList, unsigned ExtNum,
    184                               ASTContext &C)
    185 {
    186   if (data().ExternallyCompleted)
    187     LoadExternalDefinition();
    188 
    189   if (data().AllReferencedProtocols.empty() &&
    190       data().ReferencedProtocols.empty()) {
    191     data().AllReferencedProtocols.set(ExtList, ExtNum, C);
    192     return;
    193   }
    194 
    195   // Check for duplicate protocol in class's protocol list.
    196   // This is O(n*m). But it is extremely rare and number of protocols in
    197   // class or its extension are very few.
    198   SmallVector<ObjCProtocolDecl*, 8> ProtocolRefs;
    199   for (unsigned i = 0; i < ExtNum; i++) {
    200     bool protocolExists = false;
    201     ObjCProtocolDecl *ProtoInExtension = ExtList[i];
    202     for (all_protocol_iterator
    203           p = all_referenced_protocol_begin(),
    204           e = all_referenced_protocol_end(); p != e; ++p) {
    205       ObjCProtocolDecl *Proto = (*p);
    206       if (C.ProtocolCompatibleWithProtocol(ProtoInExtension, Proto)) {
    207         protocolExists = true;
    208         break;
    209       }
    210     }
    211     // Do we want to warn on a protocol in extension class which
    212     // already exist in the class? Probably not.
    213     if (!protocolExists)
    214       ProtocolRefs.push_back(ProtoInExtension);
    215   }
    216 
    217   if (ProtocolRefs.empty())
    218     return;
    219 
    220   // Merge ProtocolRefs into class's protocol list;
    221   for (all_protocol_iterator p = all_referenced_protocol_begin(),
    222         e = all_referenced_protocol_end(); p != e; ++p) {
    223     ProtocolRefs.push_back(*p);
    224   }
    225 
    226   data().AllReferencedProtocols.set(ProtocolRefs.data(), ProtocolRefs.size(),C);
    227 }
    228 
    229 void ObjCInterfaceDecl::allocateDefinitionData() {
    230   assert(!hasDefinition() && "ObjC class already has a definition");
    231   Data = new (getASTContext()) DefinitionData();
    232   Data->Definition = this;
    233 
    234   // Make the type point at the definition, now that we have one.
    235   if (TypeForDecl)
    236     cast<ObjCInterfaceType>(TypeForDecl)->Decl = this;
    237 }
    238 
    239 void ObjCInterfaceDecl::startDefinition() {
    240   allocateDefinitionData();
    241 
    242   // Update all of the declarations with a pointer to the definition.
    243   for (redecl_iterator RD = redecls_begin(), RDEnd = redecls_end();
    244        RD != RDEnd; ++RD) {
    245     if (*RD != this)
    246       RD->Data = Data;
    247   }
    248 }
    249 
    250 /// getFirstClassExtension - Find first class extension of the given class.
    251 ObjCCategoryDecl* ObjCInterfaceDecl::getFirstClassExtension() const {
    252   for (ObjCCategoryDecl *CDecl = getCategoryList(); CDecl;
    253        CDecl = CDecl->getNextClassCategory())
    254     if (CDecl->IsClassExtension())
    255       return CDecl;
    256   return 0;
    257 }
    258 
    259 /// getNextClassCategory - Find next class extension in list of categories.
    260 const ObjCCategoryDecl* ObjCCategoryDecl::getNextClassExtension() const {
    261   for (const ObjCCategoryDecl *CDecl = getNextClassCategory(); CDecl;
    262         CDecl = CDecl->getNextClassCategory())
    263     if (CDecl->IsClassExtension())
    264       return CDecl;
    265   return 0;
    266 }
    267 
    268 ObjCIvarDecl *ObjCInterfaceDecl::lookupInstanceVariable(IdentifierInfo *ID,
    269                                               ObjCInterfaceDecl *&clsDeclared) {
    270   // FIXME: Should make sure no callers ever do this.
    271   if (!hasDefinition())
    272     return 0;
    273 
    274   if (data().ExternallyCompleted)
    275     LoadExternalDefinition();
    276 
    277   ObjCInterfaceDecl* ClassDecl = this;
    278   while (ClassDecl != NULL) {
    279     if (ObjCIvarDecl *I = ClassDecl->getIvarDecl(ID)) {
    280       clsDeclared = ClassDecl;
    281       return I;
    282     }
    283     for (const ObjCCategoryDecl *CDecl = ClassDecl->getFirstClassExtension();
    284          CDecl; CDecl = CDecl->getNextClassExtension()) {
    285       if (ObjCIvarDecl *I = CDecl->getIvarDecl(ID)) {
    286         clsDeclared = ClassDecl;
    287         return I;
    288       }
    289     }
    290 
    291     ClassDecl = ClassDecl->getSuperClass();
    292   }
    293   return NULL;
    294 }
    295 
    296 /// lookupInheritedClass - This method returns ObjCInterfaceDecl * of the super
    297 /// class whose name is passed as argument. If it is not one of the super classes
    298 /// the it returns NULL.
    299 ObjCInterfaceDecl *ObjCInterfaceDecl::lookupInheritedClass(
    300                                         const IdentifierInfo*ICName) {
    301   // FIXME: Should make sure no callers ever do this.
    302   if (!hasDefinition())
    303     return 0;
    304 
    305   if (data().ExternallyCompleted)
    306     LoadExternalDefinition();
    307 
    308   ObjCInterfaceDecl* ClassDecl = this;
    309   while (ClassDecl != NULL) {
    310     if (ClassDecl->getIdentifier() == ICName)
    311       return ClassDecl;
    312     ClassDecl = ClassDecl->getSuperClass();
    313   }
    314   return NULL;
    315 }
    316 
    317 /// lookupMethod - This method returns an instance/class method by looking in
    318 /// the class, its categories, and its super classes (using a linear search).
    319 ObjCMethodDecl *ObjCInterfaceDecl::lookupMethod(Selector Sel,
    320                                      bool isInstance,
    321                                      bool shallowCategoryLookup) const {
    322   // FIXME: Should make sure no callers ever do this.
    323   if (!hasDefinition())
    324     return 0;
    325 
    326   const ObjCInterfaceDecl* ClassDecl = this;
    327   ObjCMethodDecl *MethodDecl = 0;
    328 
    329   if (data().ExternallyCompleted)
    330     LoadExternalDefinition();
    331 
    332   while (ClassDecl != NULL) {
    333     if ((MethodDecl = ClassDecl->getMethod(Sel, isInstance)))
    334       return MethodDecl;
    335 
    336     // Didn't find one yet - look through protocols.
    337     for (ObjCInterfaceDecl::protocol_iterator I = ClassDecl->protocol_begin(),
    338                                               E = ClassDecl->protocol_end();
    339            I != E; ++I)
    340       if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance)))
    341         return MethodDecl;
    342 
    343     // Didn't find one yet - now look through categories.
    344     ObjCCategoryDecl *CatDecl = ClassDecl->getCategoryList();
    345     while (CatDecl) {
    346       if ((MethodDecl = CatDecl->getMethod(Sel, isInstance)))
    347         return MethodDecl;
    348 
    349       if (!shallowCategoryLookup) {
    350         // Didn't find one yet - look through protocols.
    351         const ObjCList<ObjCProtocolDecl> &Protocols =
    352           CatDecl->getReferencedProtocols();
    353         for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
    354              E = Protocols.end(); I != E; ++I)
    355           if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance)))
    356             return MethodDecl;
    357       }
    358       CatDecl = CatDecl->getNextClassCategory();
    359     }
    360 
    361     ClassDecl = ClassDecl->getSuperClass();
    362   }
    363   return NULL;
    364 }
    365 
    366 // Will search "local" class/category implementations for a method decl.
    367 // If failed, then we search in class's root for an instance method.
    368 // Returns 0 if no method is found.
    369 ObjCMethodDecl *ObjCInterfaceDecl::lookupPrivateMethod(
    370                                    const Selector &Sel,
    371                                    bool Instance) const {
    372   // FIXME: Should make sure no callers ever do this.
    373   if (!hasDefinition())
    374     return 0;
    375 
    376   if (data().ExternallyCompleted)
    377     LoadExternalDefinition();
    378 
    379   ObjCMethodDecl *Method = 0;
    380   if (ObjCImplementationDecl *ImpDecl = getImplementation())
    381     Method = Instance ? ImpDecl->getInstanceMethod(Sel)
    382                       : ImpDecl->getClassMethod(Sel);
    383 
    384   // Look through local category implementations associated with the class.
    385   if (!Method)
    386     Method = Instance ? getCategoryInstanceMethod(Sel)
    387                       : getCategoryClassMethod(Sel);
    388 
    389   // Before we give up, check if the selector is an instance method.
    390   // But only in the root. This matches gcc's behavior and what the
    391   // runtime expects.
    392   if (!Instance && !Method && !getSuperClass()) {
    393     Method = lookupInstanceMethod(Sel);
    394     // Look through local category implementations associated
    395     // with the root class.
    396     if (!Method)
    397       Method = lookupPrivateMethod(Sel, true);
    398   }
    399 
    400   if (!Method && getSuperClass())
    401     return getSuperClass()->lookupPrivateMethod(Sel, Instance);
    402   return Method;
    403 }
    404 
    405 //===----------------------------------------------------------------------===//
    406 // ObjCMethodDecl
    407 //===----------------------------------------------------------------------===//
    408 
    409 ObjCMethodDecl *ObjCMethodDecl::Create(ASTContext &C,
    410                                        SourceLocation beginLoc,
    411                                        SourceLocation endLoc,
    412                                        Selector SelInfo, QualType T,
    413                                        TypeSourceInfo *ResultTInfo,
    414                                        DeclContext *contextDecl,
    415                                        bool isInstance,
    416                                        bool isVariadic,
    417                                        bool isSynthesized,
    418                                        bool isImplicitlyDeclared,
    419                                        bool isDefined,
    420                                        ImplementationControl impControl,
    421                                        bool HasRelatedResultType) {
    422   return new (C) ObjCMethodDecl(beginLoc, endLoc,
    423                                 SelInfo, T, ResultTInfo, contextDecl,
    424                                 isInstance,
    425                                 isVariadic, isSynthesized, isImplicitlyDeclared,
    426                                 isDefined,
    427                                 impControl,
    428                                 HasRelatedResultType);
    429 }
    430 
    431 ObjCMethodDecl *ObjCMethodDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
    432   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCMethodDecl));
    433   return new (Mem) ObjCMethodDecl(SourceLocation(), SourceLocation(),
    434                                   Selector(), QualType(), 0, 0);
    435 }
    436 
    437 void ObjCMethodDecl::setAsRedeclaration(const ObjCMethodDecl *PrevMethod) {
    438   assert(PrevMethod);
    439   getASTContext().setObjCMethodRedeclaration(PrevMethod, this);
    440   IsRedeclaration = true;
    441   PrevMethod->HasRedeclaration = true;
    442 }
    443 
    444 void ObjCMethodDecl::setParamsAndSelLocs(ASTContext &C,
    445                                          ArrayRef<ParmVarDecl*> Params,
    446                                          ArrayRef<SourceLocation> SelLocs) {
    447   ParamsAndSelLocs = 0;
    448   NumParams = Params.size();
    449   if (Params.empty() && SelLocs.empty())
    450     return;
    451 
    452   unsigned Size = sizeof(ParmVarDecl *) * NumParams +
    453                   sizeof(SourceLocation) * SelLocs.size();
    454   ParamsAndSelLocs = C.Allocate(Size);
    455   std::copy(Params.begin(), Params.end(), getParams());
    456   std::copy(SelLocs.begin(), SelLocs.end(), getStoredSelLocs());
    457 }
    458 
    459 void ObjCMethodDecl::getSelectorLocs(
    460                                SmallVectorImpl<SourceLocation> &SelLocs) const {
    461   for (unsigned i = 0, e = getNumSelectorLocs(); i != e; ++i)
    462     SelLocs.push_back(getSelectorLoc(i));
    463 }
    464 
    465 void ObjCMethodDecl::setMethodParams(ASTContext &C,
    466                                      ArrayRef<ParmVarDecl*> Params,
    467                                      ArrayRef<SourceLocation> SelLocs) {
    468   assert((!SelLocs.empty() || isImplicit()) &&
    469          "No selector locs for non-implicit method");
    470   if (isImplicit())
    471     return setParamsAndSelLocs(C, Params, ArrayRef<SourceLocation>());
    472 
    473   SelLocsKind = hasStandardSelectorLocs(getSelector(), SelLocs, Params,
    474                                         DeclEndLoc);
    475   if (SelLocsKind != SelLoc_NonStandard)
    476     return setParamsAndSelLocs(C, Params, ArrayRef<SourceLocation>());
    477 
    478   setParamsAndSelLocs(C, Params, SelLocs);
    479 }
    480 
    481 /// \brief A definition will return its interface declaration.
    482 /// An interface declaration will return its definition.
    483 /// Otherwise it will return itself.
    484 ObjCMethodDecl *ObjCMethodDecl::getNextRedeclaration() {
    485   ASTContext &Ctx = getASTContext();
    486   ObjCMethodDecl *Redecl = 0;
    487   if (HasRedeclaration)
    488     Redecl = const_cast<ObjCMethodDecl*>(Ctx.getObjCMethodRedeclaration(this));
    489   if (Redecl)
    490     return Redecl;
    491 
    492   Decl *CtxD = cast<Decl>(getDeclContext());
    493 
    494   if (ObjCInterfaceDecl *IFD = dyn_cast<ObjCInterfaceDecl>(CtxD)) {
    495     if (ObjCImplementationDecl *ImplD = Ctx.getObjCImplementation(IFD))
    496       Redecl = ImplD->getMethod(getSelector(), isInstanceMethod());
    497 
    498   } else if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CtxD)) {
    499     if (ObjCCategoryImplDecl *ImplD = Ctx.getObjCImplementation(CD))
    500       Redecl = ImplD->getMethod(getSelector(), isInstanceMethod());
    501 
    502   } else if (ObjCImplementationDecl *ImplD =
    503                dyn_cast<ObjCImplementationDecl>(CtxD)) {
    504     if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
    505       Redecl = IFD->getMethod(getSelector(), isInstanceMethod());
    506 
    507   } else if (ObjCCategoryImplDecl *CImplD =
    508                dyn_cast<ObjCCategoryImplDecl>(CtxD)) {
    509     if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl())
    510       Redecl = CatD->getMethod(getSelector(), isInstanceMethod());
    511   }
    512 
    513   if (!Redecl && isRedeclaration()) {
    514     // This is the last redeclaration, go back to the first method.
    515     return cast<ObjCContainerDecl>(CtxD)->getMethod(getSelector(),
    516                                                     isInstanceMethod());
    517   }
    518 
    519   return Redecl ? Redecl : this;
    520 }
    521 
    522 ObjCMethodDecl *ObjCMethodDecl::getCanonicalDecl() {
    523   Decl *CtxD = cast<Decl>(getDeclContext());
    524 
    525   if (ObjCImplementationDecl *ImplD = dyn_cast<ObjCImplementationDecl>(CtxD)) {
    526     if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
    527       if (ObjCMethodDecl *MD = IFD->getMethod(getSelector(),
    528                                               isInstanceMethod()))
    529         return MD;
    530 
    531   } else if (ObjCCategoryImplDecl *CImplD =
    532                dyn_cast<ObjCCategoryImplDecl>(CtxD)) {
    533     if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl())
    534       if (ObjCMethodDecl *MD = CatD->getMethod(getSelector(),
    535                                                isInstanceMethod()))
    536         return MD;
    537   }
    538 
    539   if (isRedeclaration())
    540     return cast<ObjCContainerDecl>(CtxD)->getMethod(getSelector(),
    541                                                     isInstanceMethod());
    542 
    543   return this;
    544 }
    545 
    546 SourceLocation ObjCMethodDecl::getLocEnd() const {
    547   if (Stmt *Body = getBody())
    548     return Body->getLocEnd();
    549   return DeclEndLoc;
    550 }
    551 
    552 ObjCMethodFamily ObjCMethodDecl::getMethodFamily() const {
    553   ObjCMethodFamily family = static_cast<ObjCMethodFamily>(Family);
    554   if (family != static_cast<unsigned>(InvalidObjCMethodFamily))
    555     return family;
    556 
    557   // Check for an explicit attribute.
    558   if (const ObjCMethodFamilyAttr *attr = getAttr<ObjCMethodFamilyAttr>()) {
    559     // The unfortunate necessity of mapping between enums here is due
    560     // to the attributes framework.
    561     switch (attr->getFamily()) {
    562     case ObjCMethodFamilyAttr::OMF_None: family = OMF_None; break;
    563     case ObjCMethodFamilyAttr::OMF_alloc: family = OMF_alloc; break;
    564     case ObjCMethodFamilyAttr::OMF_copy: family = OMF_copy; break;
    565     case ObjCMethodFamilyAttr::OMF_init: family = OMF_init; break;
    566     case ObjCMethodFamilyAttr::OMF_mutableCopy: family = OMF_mutableCopy; break;
    567     case ObjCMethodFamilyAttr::OMF_new: family = OMF_new; break;
    568     }
    569     Family = static_cast<unsigned>(family);
    570     return family;
    571   }
    572 
    573   family = getSelector().getMethodFamily();
    574   switch (family) {
    575   case OMF_None: break;
    576 
    577   // init only has a conventional meaning for an instance method, and
    578   // it has to return an object.
    579   case OMF_init:
    580     if (!isInstanceMethod() || !getResultType()->isObjCObjectPointerType())
    581       family = OMF_None;
    582     break;
    583 
    584   // alloc/copy/new have a conventional meaning for both class and
    585   // instance methods, but they require an object return.
    586   case OMF_alloc:
    587   case OMF_copy:
    588   case OMF_mutableCopy:
    589   case OMF_new:
    590     if (!getResultType()->isObjCObjectPointerType())
    591       family = OMF_None;
    592     break;
    593 
    594   // These selectors have a conventional meaning only for instance methods.
    595   case OMF_dealloc:
    596   case OMF_finalize:
    597   case OMF_retain:
    598   case OMF_release:
    599   case OMF_autorelease:
    600   case OMF_retainCount:
    601   case OMF_self:
    602     if (!isInstanceMethod())
    603       family = OMF_None;
    604     break;
    605 
    606   case OMF_performSelector:
    607     if (!isInstanceMethod() ||
    608         !getResultType()->isObjCIdType())
    609       family = OMF_None;
    610     else {
    611       unsigned noParams = param_size();
    612       if (noParams < 1 || noParams > 3)
    613         family = OMF_None;
    614       else {
    615         ObjCMethodDecl::arg_type_iterator it = arg_type_begin();
    616         QualType ArgT = (*it);
    617         if (!ArgT->isObjCSelType()) {
    618           family = OMF_None;
    619           break;
    620         }
    621         while (--noParams) {
    622           it++;
    623           ArgT = (*it);
    624           if (!ArgT->isObjCIdType()) {
    625             family = OMF_None;
    626             break;
    627           }
    628         }
    629       }
    630     }
    631     break;
    632 
    633   }
    634 
    635   // Cache the result.
    636   Family = static_cast<unsigned>(family);
    637   return family;
    638 }
    639 
    640 void ObjCMethodDecl::createImplicitParams(ASTContext &Context,
    641                                           const ObjCInterfaceDecl *OID) {
    642   QualType selfTy;
    643   if (isInstanceMethod()) {
    644     // There may be no interface context due to error in declaration
    645     // of the interface (which has been reported). Recover gracefully.
    646     if (OID) {
    647       selfTy = Context.getObjCInterfaceType(OID);
    648       selfTy = Context.getObjCObjectPointerType(selfTy);
    649     } else {
    650       selfTy = Context.getObjCIdType();
    651     }
    652   } else // we have a factory method.
    653     selfTy = Context.getObjCClassType();
    654 
    655   bool selfIsPseudoStrong = false;
    656   bool selfIsConsumed = false;
    657 
    658   if (Context.getLangOpts().ObjCAutoRefCount) {
    659     if (isInstanceMethod()) {
    660       selfIsConsumed = hasAttr<NSConsumesSelfAttr>();
    661 
    662       // 'self' is always __strong.  It's actually pseudo-strong except
    663       // in init methods (or methods labeled ns_consumes_self), though.
    664       Qualifiers qs;
    665       qs.setObjCLifetime(Qualifiers::OCL_Strong);
    666       selfTy = Context.getQualifiedType(selfTy, qs);
    667 
    668       // In addition, 'self' is const unless this is an init method.
    669       if (getMethodFamily() != OMF_init && !selfIsConsumed) {
    670         selfTy = selfTy.withConst();
    671         selfIsPseudoStrong = true;
    672       }
    673     }
    674     else {
    675       assert(isClassMethod());
    676       // 'self' is always const in class methods.
    677       selfTy = selfTy.withConst();
    678       selfIsPseudoStrong = true;
    679     }
    680   }
    681 
    682   ImplicitParamDecl *self
    683     = ImplicitParamDecl::Create(Context, this, SourceLocation(),
    684                                 &Context.Idents.get("self"), selfTy);
    685   setSelfDecl(self);
    686 
    687   if (selfIsConsumed)
    688     self->addAttr(new (Context) NSConsumedAttr(SourceLocation(), Context));
    689 
    690   if (selfIsPseudoStrong)
    691     self->setARCPseudoStrong(true);
    692 
    693   setCmdDecl(ImplicitParamDecl::Create(Context, this, SourceLocation(),
    694                                        &Context.Idents.get("_cmd"),
    695                                        Context.getObjCSelType()));
    696 }
    697 
    698 ObjCInterfaceDecl *ObjCMethodDecl::getClassInterface() {
    699   if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(getDeclContext()))
    700     return ID;
    701   if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(getDeclContext()))
    702     return CD->getClassInterface();
    703   if (ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(getDeclContext()))
    704     return IMD->getClassInterface();
    705 
    706   assert(!isa<ObjCProtocolDecl>(getDeclContext()) && "It's a protocol method");
    707   llvm_unreachable("unknown method context");
    708 }
    709 
    710 //===----------------------------------------------------------------------===//
    711 // ObjCInterfaceDecl
    712 //===----------------------------------------------------------------------===//
    713 
    714 ObjCInterfaceDecl *ObjCInterfaceDecl::Create(const ASTContext &C,
    715                                              DeclContext *DC,
    716                                              SourceLocation atLoc,
    717                                              IdentifierInfo *Id,
    718                                              ObjCInterfaceDecl *PrevDecl,
    719                                              SourceLocation ClassLoc,
    720                                              bool isInternal){
    721   ObjCInterfaceDecl *Result = new (C) ObjCInterfaceDecl(DC, atLoc, Id, ClassLoc,
    722                                                         PrevDecl, isInternal);
    723   C.getObjCInterfaceType(Result, PrevDecl);
    724   return Result;
    725 }
    726 
    727 ObjCInterfaceDecl *ObjCInterfaceDecl::CreateDeserialized(ASTContext &C,
    728                                                          unsigned ID) {
    729   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCInterfaceDecl));
    730   return new (Mem) ObjCInterfaceDecl(0, SourceLocation(), 0, SourceLocation(),
    731                                      0, false);
    732 }
    733 
    734 ObjCInterfaceDecl::
    735 ObjCInterfaceDecl(DeclContext *DC, SourceLocation atLoc, IdentifierInfo *Id,
    736                   SourceLocation CLoc, ObjCInterfaceDecl *PrevDecl,
    737                   bool isInternal)
    738   : ObjCContainerDecl(ObjCInterface, DC, Id, CLoc, atLoc),
    739     TypeForDecl(0), Data()
    740 {
    741   setPreviousDeclaration(PrevDecl);
    742 
    743   // Copy the 'data' pointer over.
    744   if (PrevDecl)
    745     Data = PrevDecl->Data;
    746 
    747   setImplicit(isInternal);
    748 }
    749 
    750 void ObjCInterfaceDecl::LoadExternalDefinition() const {
    751   assert(data().ExternallyCompleted && "Class is not externally completed");
    752   data().ExternallyCompleted = false;
    753   getASTContext().getExternalSource()->CompleteType(
    754                                         const_cast<ObjCInterfaceDecl *>(this));
    755 }
    756 
    757 void ObjCInterfaceDecl::setExternallyCompleted() {
    758   assert(getASTContext().getExternalSource() &&
    759          "Class can't be externally completed without an external source");
    760   assert(hasDefinition() &&
    761          "Forward declarations can't be externally completed");
    762   data().ExternallyCompleted = true;
    763 }
    764 
    765 ObjCImplementationDecl *ObjCInterfaceDecl::getImplementation() const {
    766   if (const ObjCInterfaceDecl *Def = getDefinition()) {
    767     if (data().ExternallyCompleted)
    768       LoadExternalDefinition();
    769 
    770     return getASTContext().getObjCImplementation(
    771              const_cast<ObjCInterfaceDecl*>(Def));
    772   }
    773 
    774   // FIXME: Should make sure no callers ever do this.
    775   return 0;
    776 }
    777 
    778 void ObjCInterfaceDecl::setImplementation(ObjCImplementationDecl *ImplD) {
    779   getASTContext().setObjCImplementation(getDefinition(), ImplD);
    780 }
    781 
    782 /// all_declared_ivar_begin - return first ivar declared in this class,
    783 /// its extensions and its implementation. Lazily build the list on first
    784 /// access.
    785 ObjCIvarDecl *ObjCInterfaceDecl::all_declared_ivar_begin() {
    786   // FIXME: Should make sure no callers ever do this.
    787   if (!hasDefinition())
    788     return 0;
    789 
    790   if (data().IvarList)
    791     return data().IvarList;
    792 
    793   ObjCIvarDecl *curIvar = 0;
    794   if (!ivar_empty()) {
    795     ObjCInterfaceDecl::ivar_iterator I = ivar_begin(), E = ivar_end();
    796     data().IvarList = *I; ++I;
    797     for (curIvar = data().IvarList; I != E; curIvar = *I, ++I)
    798       curIvar->setNextIvar(*I);
    799   }
    800 
    801   for (const ObjCCategoryDecl *CDecl = getFirstClassExtension(); CDecl;
    802        CDecl = CDecl->getNextClassExtension()) {
    803     if (!CDecl->ivar_empty()) {
    804       ObjCCategoryDecl::ivar_iterator I = CDecl->ivar_begin(),
    805                                           E = CDecl->ivar_end();
    806       if (!data().IvarList) {
    807         data().IvarList = *I; ++I;
    808         curIvar = data().IvarList;
    809       }
    810       for ( ;I != E; curIvar = *I, ++I)
    811         curIvar->setNextIvar(*I);
    812     }
    813   }
    814 
    815   if (ObjCImplementationDecl *ImplDecl = getImplementation()) {
    816     if (!ImplDecl->ivar_empty()) {
    817       ObjCImplementationDecl::ivar_iterator I = ImplDecl->ivar_begin(),
    818                                             E = ImplDecl->ivar_end();
    819       if (!data().IvarList) {
    820         data().IvarList = *I; ++I;
    821         curIvar = data().IvarList;
    822       }
    823       for ( ;I != E; curIvar = *I, ++I)
    824         curIvar->setNextIvar(*I);
    825     }
    826   }
    827   return data().IvarList;
    828 }
    829 
    830 /// FindCategoryDeclaration - Finds category declaration in the list of
    831 /// categories for this class and returns it. Name of the category is passed
    832 /// in 'CategoryId'. If category not found, return 0;
    833 ///
    834 ObjCCategoryDecl *
    835 ObjCInterfaceDecl::FindCategoryDeclaration(IdentifierInfo *CategoryId) const {
    836   // FIXME: Should make sure no callers ever do this.
    837   if (!hasDefinition())
    838     return 0;
    839 
    840   if (data().ExternallyCompleted)
    841     LoadExternalDefinition();
    842 
    843   for (ObjCCategoryDecl *Category = getCategoryList();
    844        Category; Category = Category->getNextClassCategory())
    845     if (Category->getIdentifier() == CategoryId)
    846       return Category;
    847   return 0;
    848 }
    849 
    850 ObjCMethodDecl *
    851 ObjCInterfaceDecl::getCategoryInstanceMethod(Selector Sel) const {
    852   for (ObjCCategoryDecl *Category = getCategoryList();
    853        Category; Category = Category->getNextClassCategory())
    854     if (ObjCCategoryImplDecl *Impl = Category->getImplementation())
    855       if (ObjCMethodDecl *MD = Impl->getInstanceMethod(Sel))
    856         return MD;
    857   return 0;
    858 }
    859 
    860 ObjCMethodDecl *ObjCInterfaceDecl::getCategoryClassMethod(Selector Sel) const {
    861   for (ObjCCategoryDecl *Category = getCategoryList();
    862        Category; Category = Category->getNextClassCategory())
    863     if (ObjCCategoryImplDecl *Impl = Category->getImplementation())
    864       if (ObjCMethodDecl *MD = Impl->getClassMethod(Sel))
    865         return MD;
    866   return 0;
    867 }
    868 
    869 /// ClassImplementsProtocol - Checks that 'lProto' protocol
    870 /// has been implemented in IDecl class, its super class or categories (if
    871 /// lookupCategory is true).
    872 bool ObjCInterfaceDecl::ClassImplementsProtocol(ObjCProtocolDecl *lProto,
    873                                     bool lookupCategory,
    874                                     bool RHSIsQualifiedID) {
    875   if (!hasDefinition())
    876     return false;
    877 
    878   ObjCInterfaceDecl *IDecl = this;
    879   // 1st, look up the class.
    880   for (ObjCInterfaceDecl::protocol_iterator
    881         PI = IDecl->protocol_begin(), E = IDecl->protocol_end(); PI != E; ++PI){
    882     if (getASTContext().ProtocolCompatibleWithProtocol(lProto, *PI))
    883       return true;
    884     // This is dubious and is added to be compatible with gcc.  In gcc, it is
    885     // also allowed assigning a protocol-qualified 'id' type to a LHS object
    886     // when protocol in qualified LHS is in list of protocols in the rhs 'id'
    887     // object. This IMO, should be a bug.
    888     // FIXME: Treat this as an extension, and flag this as an error when GCC
    889     // extensions are not enabled.
    890     if (RHSIsQualifiedID &&
    891         getASTContext().ProtocolCompatibleWithProtocol(*PI, lProto))
    892       return true;
    893   }
    894 
    895   // 2nd, look up the category.
    896   if (lookupCategory)
    897     for (ObjCCategoryDecl *CDecl = IDecl->getCategoryList(); CDecl;
    898          CDecl = CDecl->getNextClassCategory()) {
    899       for (ObjCCategoryDecl::protocol_iterator PI = CDecl->protocol_begin(),
    900            E = CDecl->protocol_end(); PI != E; ++PI)
    901         if (getASTContext().ProtocolCompatibleWithProtocol(lProto, *PI))
    902           return true;
    903     }
    904 
    905   // 3rd, look up the super class(s)
    906   if (IDecl->getSuperClass())
    907     return
    908   IDecl->getSuperClass()->ClassImplementsProtocol(lProto, lookupCategory,
    909                                                   RHSIsQualifiedID);
    910 
    911   return false;
    912 }
    913 
    914 //===----------------------------------------------------------------------===//
    915 // ObjCIvarDecl
    916 //===----------------------------------------------------------------------===//
    917 
    918 void ObjCIvarDecl::anchor() { }
    919 
    920 ObjCIvarDecl *ObjCIvarDecl::Create(ASTContext &C, ObjCContainerDecl *DC,
    921                                    SourceLocation StartLoc,
    922                                    SourceLocation IdLoc, IdentifierInfo *Id,
    923                                    QualType T, TypeSourceInfo *TInfo,
    924                                    AccessControl ac, Expr *BW,
    925                                    bool synthesized) {
    926   if (DC) {
    927     // Ivar's can only appear in interfaces, implementations (via synthesized
    928     // properties), and class extensions (via direct declaration, or synthesized
    929     // properties).
    930     //
    931     // FIXME: This should really be asserting this:
    932     //   (isa<ObjCCategoryDecl>(DC) &&
    933     //    cast<ObjCCategoryDecl>(DC)->IsClassExtension()))
    934     // but unfortunately we sometimes place ivars into non-class extension
    935     // categories on error. This breaks an AST invariant, and should not be
    936     // fixed.
    937     assert((isa<ObjCInterfaceDecl>(DC) || isa<ObjCImplementationDecl>(DC) ||
    938             isa<ObjCCategoryDecl>(DC)) &&
    939            "Invalid ivar decl context!");
    940     // Once a new ivar is created in any of class/class-extension/implementation
    941     // decl contexts, the previously built IvarList must be rebuilt.
    942     ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(DC);
    943     if (!ID) {
    944       if (ObjCImplementationDecl *IM = dyn_cast<ObjCImplementationDecl>(DC))
    945         ID = IM->getClassInterface();
    946       else
    947         ID = cast<ObjCCategoryDecl>(DC)->getClassInterface();
    948     }
    949     ID->setIvarList(0);
    950   }
    951 
    952   return new (C) ObjCIvarDecl(DC, StartLoc, IdLoc, Id, T, TInfo,
    953                               ac, BW, synthesized);
    954 }
    955 
    956 ObjCIvarDecl *ObjCIvarDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
    957   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCIvarDecl));
    958   return new (Mem) ObjCIvarDecl(0, SourceLocation(), SourceLocation(), 0,
    959                                 QualType(), 0, ObjCIvarDecl::None, 0, false);
    960 }
    961 
    962 const ObjCInterfaceDecl *ObjCIvarDecl::getContainingInterface() const {
    963   const ObjCContainerDecl *DC = cast<ObjCContainerDecl>(getDeclContext());
    964 
    965   switch (DC->getKind()) {
    966   default:
    967   case ObjCCategoryImpl:
    968   case ObjCProtocol:
    969     llvm_unreachable("invalid ivar container!");
    970 
    971     // Ivars can only appear in class extension categories.
    972   case ObjCCategory: {
    973     const ObjCCategoryDecl *CD = cast<ObjCCategoryDecl>(DC);
    974     assert(CD->IsClassExtension() && "invalid container for ivar!");
    975     return CD->getClassInterface();
    976   }
    977 
    978   case ObjCImplementation:
    979     return cast<ObjCImplementationDecl>(DC)->getClassInterface();
    980 
    981   case ObjCInterface:
    982     return cast<ObjCInterfaceDecl>(DC);
    983   }
    984 }
    985 
    986 //===----------------------------------------------------------------------===//
    987 // ObjCAtDefsFieldDecl
    988 //===----------------------------------------------------------------------===//
    989 
    990 void ObjCAtDefsFieldDecl::anchor() { }
    991 
    992 ObjCAtDefsFieldDecl
    993 *ObjCAtDefsFieldDecl::Create(ASTContext &C, DeclContext *DC,
    994                              SourceLocation StartLoc,  SourceLocation IdLoc,
    995                              IdentifierInfo *Id, QualType T, Expr *BW) {
    996   return new (C) ObjCAtDefsFieldDecl(DC, StartLoc, IdLoc, Id, T, BW);
    997 }
    998 
    999 ObjCAtDefsFieldDecl *ObjCAtDefsFieldDecl::CreateDeserialized(ASTContext &C,
   1000                                                              unsigned ID) {
   1001   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCAtDefsFieldDecl));
   1002   return new (Mem) ObjCAtDefsFieldDecl(0, SourceLocation(), SourceLocation(),
   1003                                        0, QualType(), 0);
   1004 }
   1005 
   1006 //===----------------------------------------------------------------------===//
   1007 // ObjCProtocolDecl
   1008 //===----------------------------------------------------------------------===//
   1009 
   1010 void ObjCProtocolDecl::anchor() { }
   1011 
   1012 ObjCProtocolDecl::ObjCProtocolDecl(DeclContext *DC, IdentifierInfo *Id,
   1013                                    SourceLocation nameLoc,
   1014                                    SourceLocation atStartLoc,
   1015                                    ObjCProtocolDecl *PrevDecl)
   1016   : ObjCContainerDecl(ObjCProtocol, DC, Id, nameLoc, atStartLoc), Data()
   1017 {
   1018   setPreviousDeclaration(PrevDecl);
   1019   if (PrevDecl)
   1020     Data = PrevDecl->Data;
   1021 }
   1022 
   1023 ObjCProtocolDecl *ObjCProtocolDecl::Create(ASTContext &C, DeclContext *DC,
   1024                                            IdentifierInfo *Id,
   1025                                            SourceLocation nameLoc,
   1026                                            SourceLocation atStartLoc,
   1027                                            ObjCProtocolDecl *PrevDecl) {
   1028   ObjCProtocolDecl *Result
   1029     = new (C) ObjCProtocolDecl(DC, Id, nameLoc, atStartLoc, PrevDecl);
   1030 
   1031   return Result;
   1032 }
   1033 
   1034 ObjCProtocolDecl *ObjCProtocolDecl::CreateDeserialized(ASTContext &C,
   1035                                                        unsigned ID) {
   1036   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCProtocolDecl));
   1037   return new (Mem) ObjCProtocolDecl(0, 0, SourceLocation(), SourceLocation(),
   1038                                     0);
   1039 }
   1040 
   1041 ObjCProtocolDecl *ObjCProtocolDecl::lookupProtocolNamed(IdentifierInfo *Name) {
   1042   ObjCProtocolDecl *PDecl = this;
   1043 
   1044   if (Name == getIdentifier())
   1045     return PDecl;
   1046 
   1047   for (protocol_iterator I = protocol_begin(), E = protocol_end(); I != E; ++I)
   1048     if ((PDecl = (*I)->lookupProtocolNamed(Name)))
   1049       return PDecl;
   1050 
   1051   return NULL;
   1052 }
   1053 
   1054 // lookupMethod - Lookup a instance/class method in the protocol and protocols
   1055 // it inherited.
   1056 ObjCMethodDecl *ObjCProtocolDecl::lookupMethod(Selector Sel,
   1057                                                bool isInstance) const {
   1058   ObjCMethodDecl *MethodDecl = NULL;
   1059 
   1060   if ((MethodDecl = getMethod(Sel, isInstance)))
   1061     return MethodDecl;
   1062 
   1063   for (protocol_iterator I = protocol_begin(), E = protocol_end(); I != E; ++I)
   1064     if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance)))
   1065       return MethodDecl;
   1066   return NULL;
   1067 }
   1068 
   1069 void ObjCProtocolDecl::allocateDefinitionData() {
   1070   assert(!Data && "Protocol already has a definition!");
   1071   Data = new (getASTContext()) DefinitionData;
   1072   Data->Definition = this;
   1073 }
   1074 
   1075 void ObjCProtocolDecl::startDefinition() {
   1076   allocateDefinitionData();
   1077 
   1078   // Update all of the declarations with a pointer to the definition.
   1079   for (redecl_iterator RD = redecls_begin(), RDEnd = redecls_end();
   1080        RD != RDEnd; ++RD)
   1081     RD->Data = this->Data;
   1082 }
   1083 
   1084 //===----------------------------------------------------------------------===//
   1085 // ObjCCategoryDecl
   1086 //===----------------------------------------------------------------------===//
   1087 
   1088 void ObjCCategoryDecl::anchor() { }
   1089 
   1090 ObjCCategoryDecl *ObjCCategoryDecl::Create(ASTContext &C, DeclContext *DC,
   1091                                            SourceLocation AtLoc,
   1092                                            SourceLocation ClassNameLoc,
   1093                                            SourceLocation CategoryNameLoc,
   1094                                            IdentifierInfo *Id,
   1095                                            ObjCInterfaceDecl *IDecl,
   1096                                            SourceLocation IvarLBraceLoc,
   1097                                            SourceLocation IvarRBraceLoc) {
   1098   ObjCCategoryDecl *CatDecl = new (C) ObjCCategoryDecl(DC, AtLoc, ClassNameLoc,
   1099                                                        CategoryNameLoc, Id,
   1100                                                        IDecl,
   1101                                                        IvarLBraceLoc, IvarRBraceLoc);
   1102   if (IDecl) {
   1103     // Link this category into its class's category list.
   1104     CatDecl->NextClassCategory = IDecl->getCategoryList();
   1105     if (IDecl->hasDefinition()) {
   1106       IDecl->setCategoryList(CatDecl);
   1107       if (ASTMutationListener *L = C.getASTMutationListener())
   1108         L->AddedObjCCategoryToInterface(CatDecl, IDecl);
   1109     }
   1110   }
   1111 
   1112   return CatDecl;
   1113 }
   1114 
   1115 ObjCCategoryDecl *ObjCCategoryDecl::CreateDeserialized(ASTContext &C,
   1116                                                        unsigned ID) {
   1117   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCCategoryDecl));
   1118   return new (Mem) ObjCCategoryDecl(0, SourceLocation(), SourceLocation(),
   1119                                     SourceLocation(), 0, 0);
   1120 }
   1121 
   1122 ObjCCategoryImplDecl *ObjCCategoryDecl::getImplementation() const {
   1123   return getASTContext().getObjCImplementation(
   1124                                            const_cast<ObjCCategoryDecl*>(this));
   1125 }
   1126 
   1127 void ObjCCategoryDecl::setImplementation(ObjCCategoryImplDecl *ImplD) {
   1128   getASTContext().setObjCImplementation(this, ImplD);
   1129 }
   1130 
   1131 
   1132 //===----------------------------------------------------------------------===//
   1133 // ObjCCategoryImplDecl
   1134 //===----------------------------------------------------------------------===//
   1135 
   1136 void ObjCCategoryImplDecl::anchor() { }
   1137 
   1138 ObjCCategoryImplDecl *
   1139 ObjCCategoryImplDecl::Create(ASTContext &C, DeclContext *DC,
   1140                              IdentifierInfo *Id,
   1141                              ObjCInterfaceDecl *ClassInterface,
   1142                              SourceLocation nameLoc,
   1143                              SourceLocation atStartLoc,
   1144                              SourceLocation CategoryNameLoc) {
   1145   if (ClassInterface && ClassInterface->hasDefinition())
   1146     ClassInterface = ClassInterface->getDefinition();
   1147   return new (C) ObjCCategoryImplDecl(DC, Id, ClassInterface,
   1148                                       nameLoc, atStartLoc, CategoryNameLoc);
   1149 }
   1150 
   1151 ObjCCategoryImplDecl *ObjCCategoryImplDecl::CreateDeserialized(ASTContext &C,
   1152                                                                unsigned ID) {
   1153   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCCategoryImplDecl));
   1154   return new (Mem) ObjCCategoryImplDecl(0, 0, 0, SourceLocation(),
   1155                                         SourceLocation(), SourceLocation());
   1156 }
   1157 
   1158 ObjCCategoryDecl *ObjCCategoryImplDecl::getCategoryDecl() const {
   1159   // The class interface might be NULL if we are working with invalid code.
   1160   if (const ObjCInterfaceDecl *ID = getClassInterface())
   1161     return ID->FindCategoryDeclaration(getIdentifier());
   1162   return 0;
   1163 }
   1164 
   1165 
   1166 void ObjCImplDecl::anchor() { }
   1167 
   1168 void ObjCImplDecl::addPropertyImplementation(ObjCPropertyImplDecl *property) {
   1169   // FIXME: The context should be correct before we get here.
   1170   property->setLexicalDeclContext(this);
   1171   addDecl(property);
   1172 }
   1173 
   1174 void ObjCImplDecl::setClassInterface(ObjCInterfaceDecl *IFace) {
   1175   ASTContext &Ctx = getASTContext();
   1176 
   1177   if (ObjCImplementationDecl *ImplD
   1178         = dyn_cast_or_null<ObjCImplementationDecl>(this)) {
   1179     if (IFace)
   1180       Ctx.setObjCImplementation(IFace, ImplD);
   1181 
   1182   } else if (ObjCCategoryImplDecl *ImplD =
   1183              dyn_cast_or_null<ObjCCategoryImplDecl>(this)) {
   1184     if (ObjCCategoryDecl *CD = IFace->FindCategoryDeclaration(getIdentifier()))
   1185       Ctx.setObjCImplementation(CD, ImplD);
   1186   }
   1187 
   1188   ClassInterface = IFace;
   1189 }
   1190 
   1191 /// FindPropertyImplIvarDecl - This method lookup the ivar in the list of
   1192 /// properties implemented in this category \@implementation block and returns
   1193 /// the implemented property that uses it.
   1194 ///
   1195 ObjCPropertyImplDecl *ObjCImplDecl::
   1196 FindPropertyImplIvarDecl(IdentifierInfo *ivarId) const {
   1197   for (propimpl_iterator i = propimpl_begin(), e = propimpl_end(); i != e; ++i){
   1198     ObjCPropertyImplDecl *PID = *i;
   1199     if (PID->getPropertyIvarDecl() &&
   1200         PID->getPropertyIvarDecl()->getIdentifier() == ivarId)
   1201       return PID;
   1202   }
   1203   return 0;
   1204 }
   1205 
   1206 /// FindPropertyImplDecl - This method looks up a previous ObjCPropertyImplDecl
   1207 /// added to the list of those properties \@synthesized/\@dynamic in this
   1208 /// category \@implementation block.
   1209 ///
   1210 ObjCPropertyImplDecl *ObjCImplDecl::
   1211 FindPropertyImplDecl(IdentifierInfo *Id) const {
   1212   for (propimpl_iterator i = propimpl_begin(), e = propimpl_end(); i != e; ++i){
   1213     ObjCPropertyImplDecl *PID = *i;
   1214     if (PID->getPropertyDecl()->getIdentifier() == Id)
   1215       return PID;
   1216   }
   1217   return 0;
   1218 }
   1219 
   1220 raw_ostream &clang::operator<<(raw_ostream &OS,
   1221                                const ObjCCategoryImplDecl &CID) {
   1222   OS << CID.getName();
   1223   return OS;
   1224 }
   1225 
   1226 //===----------------------------------------------------------------------===//
   1227 // ObjCImplementationDecl
   1228 //===----------------------------------------------------------------------===//
   1229 
   1230 void ObjCImplementationDecl::anchor() { }
   1231 
   1232 ObjCImplementationDecl *
   1233 ObjCImplementationDecl::Create(ASTContext &C, DeclContext *DC,
   1234                                ObjCInterfaceDecl *ClassInterface,
   1235                                ObjCInterfaceDecl *SuperDecl,
   1236                                SourceLocation nameLoc,
   1237                                SourceLocation atStartLoc,
   1238                                SourceLocation IvarLBraceLoc,
   1239                                SourceLocation IvarRBraceLoc) {
   1240   if (ClassInterface && ClassInterface->hasDefinition())
   1241     ClassInterface = ClassInterface->getDefinition();
   1242   return new (C) ObjCImplementationDecl(DC, ClassInterface, SuperDecl,
   1243                                         nameLoc, atStartLoc,
   1244                                         IvarLBraceLoc, IvarRBraceLoc);
   1245 }
   1246 
   1247 ObjCImplementationDecl *
   1248 ObjCImplementationDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   1249   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCImplementationDecl));
   1250   return new (Mem) ObjCImplementationDecl(0, 0, 0, SourceLocation(),
   1251                                           SourceLocation());
   1252 }
   1253 
   1254 void ObjCImplementationDecl::setIvarInitializers(ASTContext &C,
   1255                                              CXXCtorInitializer ** initializers,
   1256                                                  unsigned numInitializers) {
   1257   if (numInitializers > 0) {
   1258     NumIvarInitializers = numInitializers;
   1259     CXXCtorInitializer **ivarInitializers =
   1260     new (C) CXXCtorInitializer*[NumIvarInitializers];
   1261     memcpy(ivarInitializers, initializers,
   1262            numInitializers * sizeof(CXXCtorInitializer*));
   1263     IvarInitializers = ivarInitializers;
   1264   }
   1265 }
   1266 
   1267 raw_ostream &clang::operator<<(raw_ostream &OS,
   1268                                const ObjCImplementationDecl &ID) {
   1269   OS << ID.getName();
   1270   return OS;
   1271 }
   1272 
   1273 //===----------------------------------------------------------------------===//
   1274 // ObjCCompatibleAliasDecl
   1275 //===----------------------------------------------------------------------===//
   1276 
   1277 void ObjCCompatibleAliasDecl::anchor() { }
   1278 
   1279 ObjCCompatibleAliasDecl *
   1280 ObjCCompatibleAliasDecl::Create(ASTContext &C, DeclContext *DC,
   1281                                 SourceLocation L,
   1282                                 IdentifierInfo *Id,
   1283                                 ObjCInterfaceDecl* AliasedClass) {
   1284   return new (C) ObjCCompatibleAliasDecl(DC, L, Id, AliasedClass);
   1285 }
   1286 
   1287 ObjCCompatibleAliasDecl *
   1288 ObjCCompatibleAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   1289   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCCompatibleAliasDecl));
   1290   return new (Mem) ObjCCompatibleAliasDecl(0, SourceLocation(), 0, 0);
   1291 }
   1292 
   1293 //===----------------------------------------------------------------------===//
   1294 // ObjCPropertyDecl
   1295 //===----------------------------------------------------------------------===//
   1296 
   1297 void ObjCPropertyDecl::anchor() { }
   1298 
   1299 ObjCPropertyDecl *ObjCPropertyDecl::Create(ASTContext &C, DeclContext *DC,
   1300                                            SourceLocation L,
   1301                                            IdentifierInfo *Id,
   1302                                            SourceLocation AtLoc,
   1303                                            SourceLocation LParenLoc,
   1304                                            TypeSourceInfo *T,
   1305                                            PropertyControl propControl) {
   1306   return new (C) ObjCPropertyDecl(DC, L, Id, AtLoc, LParenLoc, T);
   1307 }
   1308 
   1309 ObjCPropertyDecl *ObjCPropertyDecl::CreateDeserialized(ASTContext &C,
   1310                                                        unsigned ID) {
   1311   void * Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCPropertyDecl));
   1312   return new (Mem) ObjCPropertyDecl(0, SourceLocation(), 0, SourceLocation(),
   1313                                     SourceLocation(),
   1314                                     0);
   1315 }
   1316 
   1317 //===----------------------------------------------------------------------===//
   1318 // ObjCPropertyImplDecl
   1319 //===----------------------------------------------------------------------===//
   1320 
   1321 ObjCPropertyImplDecl *ObjCPropertyImplDecl::Create(ASTContext &C,
   1322                                                    DeclContext *DC,
   1323                                                    SourceLocation atLoc,
   1324                                                    SourceLocation L,
   1325                                                    ObjCPropertyDecl *property,
   1326                                                    Kind PK,
   1327                                                    ObjCIvarDecl *ivar,
   1328                                                    SourceLocation ivarLoc) {
   1329   return new (C) ObjCPropertyImplDecl(DC, atLoc, L, property, PK, ivar,
   1330                                       ivarLoc);
   1331 }
   1332 
   1333 ObjCPropertyImplDecl *ObjCPropertyImplDecl::CreateDeserialized(ASTContext &C,
   1334                                                                unsigned ID) {
   1335   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCPropertyImplDecl));
   1336   return new (Mem) ObjCPropertyImplDecl(0, SourceLocation(), SourceLocation(),
   1337                                         0, Dynamic, 0, SourceLocation());
   1338 }
   1339 
   1340 SourceRange ObjCPropertyImplDecl::getSourceRange() const {
   1341   SourceLocation EndLoc = getLocation();
   1342   if (IvarLoc.isValid())
   1343     EndLoc = IvarLoc;
   1344 
   1345   return SourceRange(AtLoc, EndLoc);
   1346 }
   1347