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 ObjCMethodDecl *ObjCInterfaceDecl::lookupPrivateMethod(
    367                                    const Selector &Sel,
    368                                    bool Instance) {
    369   // FIXME: Should make sure no callers ever do this.
    370   if (!hasDefinition())
    371     return 0;
    372 
    373   if (data().ExternallyCompleted)
    374     LoadExternalDefinition();
    375 
    376   ObjCMethodDecl *Method = 0;
    377   if (ObjCImplementationDecl *ImpDecl = getImplementation())
    378     Method = Instance ? ImpDecl->getInstanceMethod(Sel)
    379                       : ImpDecl->getClassMethod(Sel);
    380 
    381   if (!Method && getSuperClass())
    382     return getSuperClass()->lookupPrivateMethod(Sel, Instance);
    383   return Method;
    384 }
    385 
    386 //===----------------------------------------------------------------------===//
    387 // ObjCMethodDecl
    388 //===----------------------------------------------------------------------===//
    389 
    390 ObjCMethodDecl *ObjCMethodDecl::Create(ASTContext &C,
    391                                        SourceLocation beginLoc,
    392                                        SourceLocation endLoc,
    393                                        Selector SelInfo, QualType T,
    394                                        TypeSourceInfo *ResultTInfo,
    395                                        DeclContext *contextDecl,
    396                                        bool isInstance,
    397                                        bool isVariadic,
    398                                        bool isSynthesized,
    399                                        bool isImplicitlyDeclared,
    400                                        bool isDefined,
    401                                        ImplementationControl impControl,
    402                                        bool HasRelatedResultType) {
    403   return new (C) ObjCMethodDecl(beginLoc, endLoc,
    404                                 SelInfo, T, ResultTInfo, contextDecl,
    405                                 isInstance,
    406                                 isVariadic, isSynthesized, isImplicitlyDeclared,
    407                                 isDefined,
    408                                 impControl,
    409                                 HasRelatedResultType);
    410 }
    411 
    412 ObjCMethodDecl *ObjCMethodDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
    413   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCMethodDecl));
    414   return new (Mem) ObjCMethodDecl(SourceLocation(), SourceLocation(),
    415                                   Selector(), QualType(), 0, 0);
    416 }
    417 
    418 void ObjCMethodDecl::setAsRedeclaration(const ObjCMethodDecl *PrevMethod) {
    419   assert(PrevMethod);
    420   getASTContext().setObjCMethodRedeclaration(PrevMethod, this);
    421   IsRedeclaration = true;
    422   PrevMethod->HasRedeclaration = true;
    423 }
    424 
    425 void ObjCMethodDecl::setParamsAndSelLocs(ASTContext &C,
    426                                          ArrayRef<ParmVarDecl*> Params,
    427                                          ArrayRef<SourceLocation> SelLocs) {
    428   ParamsAndSelLocs = 0;
    429   NumParams = Params.size();
    430   if (Params.empty() && SelLocs.empty())
    431     return;
    432 
    433   unsigned Size = sizeof(ParmVarDecl *) * NumParams +
    434                   sizeof(SourceLocation) * SelLocs.size();
    435   ParamsAndSelLocs = C.Allocate(Size);
    436   std::copy(Params.begin(), Params.end(), getParams());
    437   std::copy(SelLocs.begin(), SelLocs.end(), getStoredSelLocs());
    438 }
    439 
    440 void ObjCMethodDecl::getSelectorLocs(
    441                                SmallVectorImpl<SourceLocation> &SelLocs) const {
    442   for (unsigned i = 0, e = getNumSelectorLocs(); i != e; ++i)
    443     SelLocs.push_back(getSelectorLoc(i));
    444 }
    445 
    446 void ObjCMethodDecl::setMethodParams(ASTContext &C,
    447                                      ArrayRef<ParmVarDecl*> Params,
    448                                      ArrayRef<SourceLocation> SelLocs) {
    449   assert((!SelLocs.empty() || isImplicit()) &&
    450          "No selector locs for non-implicit method");
    451   if (isImplicit())
    452     return setParamsAndSelLocs(C, Params, ArrayRef<SourceLocation>());
    453 
    454   SelLocsKind = hasStandardSelectorLocs(getSelector(), SelLocs, Params, EndLoc);
    455   if (SelLocsKind != SelLoc_NonStandard)
    456     return setParamsAndSelLocs(C, Params, ArrayRef<SourceLocation>());
    457 
    458   setParamsAndSelLocs(C, Params, SelLocs);
    459 }
    460 
    461 /// \brief A definition will return its interface declaration.
    462 /// An interface declaration will return its definition.
    463 /// Otherwise it will return itself.
    464 ObjCMethodDecl *ObjCMethodDecl::getNextRedeclaration() {
    465   ASTContext &Ctx = getASTContext();
    466   ObjCMethodDecl *Redecl = 0;
    467   if (HasRedeclaration)
    468     Redecl = const_cast<ObjCMethodDecl*>(Ctx.getObjCMethodRedeclaration(this));
    469   if (Redecl)
    470     return Redecl;
    471 
    472   Decl *CtxD = cast<Decl>(getDeclContext());
    473 
    474   if (ObjCInterfaceDecl *IFD = dyn_cast<ObjCInterfaceDecl>(CtxD)) {
    475     if (ObjCImplementationDecl *ImplD = Ctx.getObjCImplementation(IFD))
    476       Redecl = ImplD->getMethod(getSelector(), isInstanceMethod());
    477 
    478   } else if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CtxD)) {
    479     if (ObjCCategoryImplDecl *ImplD = Ctx.getObjCImplementation(CD))
    480       Redecl = ImplD->getMethod(getSelector(), isInstanceMethod());
    481 
    482   } else if (ObjCImplementationDecl *ImplD =
    483                dyn_cast<ObjCImplementationDecl>(CtxD)) {
    484     if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
    485       Redecl = IFD->getMethod(getSelector(), isInstanceMethod());
    486 
    487   } else if (ObjCCategoryImplDecl *CImplD =
    488                dyn_cast<ObjCCategoryImplDecl>(CtxD)) {
    489     if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl())
    490       Redecl = CatD->getMethod(getSelector(), isInstanceMethod());
    491   }
    492 
    493   if (!Redecl && isRedeclaration()) {
    494     // This is the last redeclaration, go back to the first method.
    495     return cast<ObjCContainerDecl>(CtxD)->getMethod(getSelector(),
    496                                                     isInstanceMethod());
    497   }
    498 
    499   return Redecl ? Redecl : this;
    500 }
    501 
    502 ObjCMethodDecl *ObjCMethodDecl::getCanonicalDecl() {
    503   Decl *CtxD = cast<Decl>(getDeclContext());
    504 
    505   if (ObjCImplementationDecl *ImplD = dyn_cast<ObjCImplementationDecl>(CtxD)) {
    506     if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
    507       if (ObjCMethodDecl *MD = IFD->getMethod(getSelector(),
    508                                               isInstanceMethod()))
    509         return MD;
    510 
    511   } else if (ObjCCategoryImplDecl *CImplD =
    512                dyn_cast<ObjCCategoryImplDecl>(CtxD)) {
    513     if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl())
    514       if (ObjCMethodDecl *MD = CatD->getMethod(getSelector(),
    515                                                isInstanceMethod()))
    516         return MD;
    517   }
    518 
    519   if (isRedeclaration())
    520     return cast<ObjCContainerDecl>(CtxD)->getMethod(getSelector(),
    521                                                     isInstanceMethod());
    522 
    523   return this;
    524 }
    525 
    526 ObjCMethodFamily ObjCMethodDecl::getMethodFamily() const {
    527   ObjCMethodFamily family = static_cast<ObjCMethodFamily>(Family);
    528   if (family != static_cast<unsigned>(InvalidObjCMethodFamily))
    529     return family;
    530 
    531   // Check for an explicit attribute.
    532   if (const ObjCMethodFamilyAttr *attr = getAttr<ObjCMethodFamilyAttr>()) {
    533     // The unfortunate necessity of mapping between enums here is due
    534     // to the attributes framework.
    535     switch (attr->getFamily()) {
    536     case ObjCMethodFamilyAttr::OMF_None: family = OMF_None; break;
    537     case ObjCMethodFamilyAttr::OMF_alloc: family = OMF_alloc; break;
    538     case ObjCMethodFamilyAttr::OMF_copy: family = OMF_copy; break;
    539     case ObjCMethodFamilyAttr::OMF_init: family = OMF_init; break;
    540     case ObjCMethodFamilyAttr::OMF_mutableCopy: family = OMF_mutableCopy; break;
    541     case ObjCMethodFamilyAttr::OMF_new: family = OMF_new; break;
    542     }
    543     Family = static_cast<unsigned>(family);
    544     return family;
    545   }
    546 
    547   family = getSelector().getMethodFamily();
    548   switch (family) {
    549   case OMF_None: break;
    550 
    551   // init only has a conventional meaning for an instance method, and
    552   // it has to return an object.
    553   case OMF_init:
    554     if (!isInstanceMethod() || !getResultType()->isObjCObjectPointerType())
    555       family = OMF_None;
    556     break;
    557 
    558   // alloc/copy/new have a conventional meaning for both class and
    559   // instance methods, but they require an object return.
    560   case OMF_alloc:
    561   case OMF_copy:
    562   case OMF_mutableCopy:
    563   case OMF_new:
    564     if (!getResultType()->isObjCObjectPointerType())
    565       family = OMF_None;
    566     break;
    567 
    568   // These selectors have a conventional meaning only for instance methods.
    569   case OMF_dealloc:
    570   case OMF_finalize:
    571   case OMF_retain:
    572   case OMF_release:
    573   case OMF_autorelease:
    574   case OMF_retainCount:
    575   case OMF_self:
    576     if (!isInstanceMethod())
    577       family = OMF_None;
    578     break;
    579 
    580   case OMF_performSelector:
    581     if (!isInstanceMethod() ||
    582         !getResultType()->isObjCIdType())
    583       family = OMF_None;
    584     else {
    585       unsigned noParams = param_size();
    586       if (noParams < 1 || noParams > 3)
    587         family = OMF_None;
    588       else {
    589         ObjCMethodDecl::arg_type_iterator it = arg_type_begin();
    590         QualType ArgT = (*it);
    591         if (!ArgT->isObjCSelType()) {
    592           family = OMF_None;
    593           break;
    594         }
    595         while (--noParams) {
    596           it++;
    597           ArgT = (*it);
    598           if (!ArgT->isObjCIdType()) {
    599             family = OMF_None;
    600             break;
    601           }
    602         }
    603       }
    604     }
    605     break;
    606 
    607   }
    608 
    609   // Cache the result.
    610   Family = static_cast<unsigned>(family);
    611   return family;
    612 }
    613 
    614 void ObjCMethodDecl::createImplicitParams(ASTContext &Context,
    615                                           const ObjCInterfaceDecl *OID) {
    616   QualType selfTy;
    617   if (isInstanceMethod()) {
    618     // There may be no interface context due to error in declaration
    619     // of the interface (which has been reported). Recover gracefully.
    620     if (OID) {
    621       selfTy = Context.getObjCInterfaceType(OID);
    622       selfTy = Context.getObjCObjectPointerType(selfTy);
    623     } else {
    624       selfTy = Context.getObjCIdType();
    625     }
    626   } else // we have a factory method.
    627     selfTy = Context.getObjCClassType();
    628 
    629   bool selfIsPseudoStrong = false;
    630   bool selfIsConsumed = false;
    631 
    632   if (Context.getLangOpts().ObjCAutoRefCount) {
    633     if (isInstanceMethod()) {
    634       selfIsConsumed = hasAttr<NSConsumesSelfAttr>();
    635 
    636       // 'self' is always __strong.  It's actually pseudo-strong except
    637       // in init methods (or methods labeled ns_consumes_self), though.
    638       Qualifiers qs;
    639       qs.setObjCLifetime(Qualifiers::OCL_Strong);
    640       selfTy = Context.getQualifiedType(selfTy, qs);
    641 
    642       // In addition, 'self' is const unless this is an init method.
    643       if (getMethodFamily() != OMF_init && !selfIsConsumed) {
    644         selfTy = selfTy.withConst();
    645         selfIsPseudoStrong = true;
    646       }
    647     }
    648     else {
    649       assert(isClassMethod());
    650       // 'self' is always const in class methods.
    651       selfTy = selfTy.withConst();
    652       selfIsPseudoStrong = true;
    653     }
    654   }
    655 
    656   ImplicitParamDecl *self
    657     = ImplicitParamDecl::Create(Context, this, SourceLocation(),
    658                                 &Context.Idents.get("self"), selfTy);
    659   setSelfDecl(self);
    660 
    661   if (selfIsConsumed)
    662     self->addAttr(new (Context) NSConsumedAttr(SourceLocation(), Context));
    663 
    664   if (selfIsPseudoStrong)
    665     self->setARCPseudoStrong(true);
    666 
    667   setCmdDecl(ImplicitParamDecl::Create(Context, this, SourceLocation(),
    668                                        &Context.Idents.get("_cmd"),
    669                                        Context.getObjCSelType()));
    670 }
    671 
    672 ObjCInterfaceDecl *ObjCMethodDecl::getClassInterface() {
    673   if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(getDeclContext()))
    674     return ID;
    675   if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(getDeclContext()))
    676     return CD->getClassInterface();
    677   if (ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(getDeclContext()))
    678     return IMD->getClassInterface();
    679 
    680   assert(!isa<ObjCProtocolDecl>(getDeclContext()) && "It's a protocol method");
    681   llvm_unreachable("unknown method context");
    682 }
    683 
    684 //===----------------------------------------------------------------------===//
    685 // ObjCInterfaceDecl
    686 //===----------------------------------------------------------------------===//
    687 
    688 ObjCInterfaceDecl *ObjCInterfaceDecl::Create(const ASTContext &C,
    689                                              DeclContext *DC,
    690                                              SourceLocation atLoc,
    691                                              IdentifierInfo *Id,
    692                                              ObjCInterfaceDecl *PrevDecl,
    693                                              SourceLocation ClassLoc,
    694                                              bool isInternal){
    695   ObjCInterfaceDecl *Result = new (C) ObjCInterfaceDecl(DC, atLoc, Id, ClassLoc,
    696                                                         PrevDecl, isInternal);
    697   C.getObjCInterfaceType(Result, PrevDecl);
    698   return Result;
    699 }
    700 
    701 ObjCInterfaceDecl *ObjCInterfaceDecl::CreateDeserialized(ASTContext &C,
    702                                                          unsigned ID) {
    703   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCInterfaceDecl));
    704   return new (Mem) ObjCInterfaceDecl(0, SourceLocation(), 0, SourceLocation(),
    705                                      0, false);
    706 }
    707 
    708 ObjCInterfaceDecl::
    709 ObjCInterfaceDecl(DeclContext *DC, SourceLocation atLoc, IdentifierInfo *Id,
    710                   SourceLocation CLoc, ObjCInterfaceDecl *PrevDecl,
    711                   bool isInternal)
    712   : ObjCContainerDecl(ObjCInterface, DC, Id, CLoc, atLoc),
    713     TypeForDecl(0), Data()
    714 {
    715   setPreviousDeclaration(PrevDecl);
    716 
    717   // Copy the 'data' pointer over.
    718   if (PrevDecl)
    719     Data = PrevDecl->Data;
    720 
    721   setImplicit(isInternal);
    722 }
    723 
    724 void ObjCInterfaceDecl::LoadExternalDefinition() const {
    725   assert(data().ExternallyCompleted && "Class is not externally completed");
    726   data().ExternallyCompleted = false;
    727   getASTContext().getExternalSource()->CompleteType(
    728                                         const_cast<ObjCInterfaceDecl *>(this));
    729 }
    730 
    731 void ObjCInterfaceDecl::setExternallyCompleted() {
    732   assert(getASTContext().getExternalSource() &&
    733          "Class can't be externally completed without an external source");
    734   assert(hasDefinition() &&
    735          "Forward declarations can't be externally completed");
    736   data().ExternallyCompleted = true;
    737 }
    738 
    739 ObjCImplementationDecl *ObjCInterfaceDecl::getImplementation() const {
    740   if (const ObjCInterfaceDecl *Def = getDefinition()) {
    741     if (data().ExternallyCompleted)
    742       LoadExternalDefinition();
    743 
    744     return getASTContext().getObjCImplementation(
    745              const_cast<ObjCInterfaceDecl*>(Def));
    746   }
    747 
    748   // FIXME: Should make sure no callers ever do this.
    749   return 0;
    750 }
    751 
    752 void ObjCInterfaceDecl::setImplementation(ObjCImplementationDecl *ImplD) {
    753   getASTContext().setObjCImplementation(getDefinition(), ImplD);
    754 }
    755 
    756 /// all_declared_ivar_begin - return first ivar declared in this class,
    757 /// its extensions and its implementation. Lazily build the list on first
    758 /// access.
    759 ObjCIvarDecl *ObjCInterfaceDecl::all_declared_ivar_begin() {
    760   // FIXME: Should make sure no callers ever do this.
    761   if (!hasDefinition())
    762     return 0;
    763 
    764   if (data().IvarList)
    765     return data().IvarList;
    766 
    767   ObjCIvarDecl *curIvar = 0;
    768   if (!ivar_empty()) {
    769     ObjCInterfaceDecl::ivar_iterator I = ivar_begin(), E = ivar_end();
    770     data().IvarList = (*I); ++I;
    771     for (curIvar = data().IvarList; I != E; curIvar = *I, ++I)
    772       curIvar->setNextIvar(*I);
    773   }
    774 
    775   for (const ObjCCategoryDecl *CDecl = getFirstClassExtension(); CDecl;
    776        CDecl = CDecl->getNextClassExtension()) {
    777     if (!CDecl->ivar_empty()) {
    778       ObjCCategoryDecl::ivar_iterator I = CDecl->ivar_begin(),
    779                                           E = CDecl->ivar_end();
    780       if (!data().IvarList) {
    781         data().IvarList = (*I); ++I;
    782         curIvar = data().IvarList;
    783       }
    784       for ( ;I != E; curIvar = *I, ++I)
    785         curIvar->setNextIvar(*I);
    786     }
    787   }
    788 
    789   if (ObjCImplementationDecl *ImplDecl = getImplementation()) {
    790     if (!ImplDecl->ivar_empty()) {
    791       ObjCImplementationDecl::ivar_iterator I = ImplDecl->ivar_begin(),
    792                                             E = ImplDecl->ivar_end();
    793       if (!data().IvarList) {
    794         data().IvarList = (*I); ++I;
    795         curIvar = data().IvarList;
    796       }
    797       for ( ;I != E; curIvar = *I, ++I)
    798         curIvar->setNextIvar(*I);
    799     }
    800   }
    801   return data().IvarList;
    802 }
    803 
    804 /// FindCategoryDeclaration - Finds category declaration in the list of
    805 /// categories for this class and returns it. Name of the category is passed
    806 /// in 'CategoryId'. If category not found, return 0;
    807 ///
    808 ObjCCategoryDecl *
    809 ObjCInterfaceDecl::FindCategoryDeclaration(IdentifierInfo *CategoryId) const {
    810   // FIXME: Should make sure no callers ever do this.
    811   if (!hasDefinition())
    812     return 0;
    813 
    814   if (data().ExternallyCompleted)
    815     LoadExternalDefinition();
    816 
    817   for (ObjCCategoryDecl *Category = getCategoryList();
    818        Category; Category = Category->getNextClassCategory())
    819     if (Category->getIdentifier() == CategoryId)
    820       return Category;
    821   return 0;
    822 }
    823 
    824 ObjCMethodDecl *
    825 ObjCInterfaceDecl::getCategoryInstanceMethod(Selector Sel) const {
    826   for (ObjCCategoryDecl *Category = getCategoryList();
    827        Category; Category = Category->getNextClassCategory())
    828     if (ObjCCategoryImplDecl *Impl = Category->getImplementation())
    829       if (ObjCMethodDecl *MD = Impl->getInstanceMethod(Sel))
    830         return MD;
    831   return 0;
    832 }
    833 
    834 ObjCMethodDecl *ObjCInterfaceDecl::getCategoryClassMethod(Selector Sel) const {
    835   for (ObjCCategoryDecl *Category = getCategoryList();
    836        Category; Category = Category->getNextClassCategory())
    837     if (ObjCCategoryImplDecl *Impl = Category->getImplementation())
    838       if (ObjCMethodDecl *MD = Impl->getClassMethod(Sel))
    839         return MD;
    840   return 0;
    841 }
    842 
    843 /// ClassImplementsProtocol - Checks that 'lProto' protocol
    844 /// has been implemented in IDecl class, its super class or categories (if
    845 /// lookupCategory is true).
    846 bool ObjCInterfaceDecl::ClassImplementsProtocol(ObjCProtocolDecl *lProto,
    847                                     bool lookupCategory,
    848                                     bool RHSIsQualifiedID) {
    849   if (!hasDefinition())
    850     return false;
    851 
    852   ObjCInterfaceDecl *IDecl = this;
    853   // 1st, look up the class.
    854   for (ObjCInterfaceDecl::protocol_iterator
    855         PI = IDecl->protocol_begin(), E = IDecl->protocol_end(); PI != E; ++PI){
    856     if (getASTContext().ProtocolCompatibleWithProtocol(lProto, *PI))
    857       return true;
    858     // This is dubious and is added to be compatible with gcc.  In gcc, it is
    859     // also allowed assigning a protocol-qualified 'id' type to a LHS object
    860     // when protocol in qualified LHS is in list of protocols in the rhs 'id'
    861     // object. This IMO, should be a bug.
    862     // FIXME: Treat this as an extension, and flag this as an error when GCC
    863     // extensions are not enabled.
    864     if (RHSIsQualifiedID &&
    865         getASTContext().ProtocolCompatibleWithProtocol(*PI, lProto))
    866       return true;
    867   }
    868 
    869   // 2nd, look up the category.
    870   if (lookupCategory)
    871     for (ObjCCategoryDecl *CDecl = IDecl->getCategoryList(); CDecl;
    872          CDecl = CDecl->getNextClassCategory()) {
    873       for (ObjCCategoryDecl::protocol_iterator PI = CDecl->protocol_begin(),
    874            E = CDecl->protocol_end(); PI != E; ++PI)
    875         if (getASTContext().ProtocolCompatibleWithProtocol(lProto, *PI))
    876           return true;
    877     }
    878 
    879   // 3rd, look up the super class(s)
    880   if (IDecl->getSuperClass())
    881     return
    882   IDecl->getSuperClass()->ClassImplementsProtocol(lProto, lookupCategory,
    883                                                   RHSIsQualifiedID);
    884 
    885   return false;
    886 }
    887 
    888 //===----------------------------------------------------------------------===//
    889 // ObjCIvarDecl
    890 //===----------------------------------------------------------------------===//
    891 
    892 void ObjCIvarDecl::anchor() { }
    893 
    894 ObjCIvarDecl *ObjCIvarDecl::Create(ASTContext &C, ObjCContainerDecl *DC,
    895                                    SourceLocation StartLoc,
    896                                    SourceLocation IdLoc, IdentifierInfo *Id,
    897                                    QualType T, TypeSourceInfo *TInfo,
    898                                    AccessControl ac, Expr *BW,
    899                                    bool synthesized) {
    900   if (DC) {
    901     // Ivar's can only appear in interfaces, implementations (via synthesized
    902     // properties), and class extensions (via direct declaration, or synthesized
    903     // properties).
    904     //
    905     // FIXME: This should really be asserting this:
    906     //   (isa<ObjCCategoryDecl>(DC) &&
    907     //    cast<ObjCCategoryDecl>(DC)->IsClassExtension()))
    908     // but unfortunately we sometimes place ivars into non-class extension
    909     // categories on error. This breaks an AST invariant, and should not be
    910     // fixed.
    911     assert((isa<ObjCInterfaceDecl>(DC) || isa<ObjCImplementationDecl>(DC) ||
    912             isa<ObjCCategoryDecl>(DC)) &&
    913            "Invalid ivar decl context!");
    914     // Once a new ivar is created in any of class/class-extension/implementation
    915     // decl contexts, the previously built IvarList must be rebuilt.
    916     ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(DC);
    917     if (!ID) {
    918       if (ObjCImplementationDecl *IM = dyn_cast<ObjCImplementationDecl>(DC)) {
    919         ID = IM->getClassInterface();
    920         if (BW)
    921           IM->setHasSynthBitfield(true);
    922       } else {
    923         ObjCCategoryDecl *CD = cast<ObjCCategoryDecl>(DC);
    924         ID = CD->getClassInterface();
    925         if (BW)
    926           CD->setHasSynthBitfield(true);
    927       }
    928     }
    929     ID->setIvarList(0);
    930   }
    931 
    932   return new (C) ObjCIvarDecl(DC, StartLoc, IdLoc, Id, T, TInfo,
    933                               ac, BW, synthesized);
    934 }
    935 
    936 ObjCIvarDecl *ObjCIvarDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
    937   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCIvarDecl));
    938   return new (Mem) ObjCIvarDecl(0, SourceLocation(), SourceLocation(), 0,
    939                                 QualType(), 0, ObjCIvarDecl::None, 0, false);
    940 }
    941 
    942 const ObjCInterfaceDecl *ObjCIvarDecl::getContainingInterface() const {
    943   const ObjCContainerDecl *DC = cast<ObjCContainerDecl>(getDeclContext());
    944 
    945   switch (DC->getKind()) {
    946   default:
    947   case ObjCCategoryImpl:
    948   case ObjCProtocol:
    949     llvm_unreachable("invalid ivar container!");
    950 
    951     // Ivars can only appear in class extension categories.
    952   case ObjCCategory: {
    953     const ObjCCategoryDecl *CD = cast<ObjCCategoryDecl>(DC);
    954     assert(CD->IsClassExtension() && "invalid container for ivar!");
    955     return CD->getClassInterface();
    956   }
    957 
    958   case ObjCImplementation:
    959     return cast<ObjCImplementationDecl>(DC)->getClassInterface();
    960 
    961   case ObjCInterface:
    962     return cast<ObjCInterfaceDecl>(DC);
    963   }
    964 }
    965 
    966 //===----------------------------------------------------------------------===//
    967 // ObjCAtDefsFieldDecl
    968 //===----------------------------------------------------------------------===//
    969 
    970 void ObjCAtDefsFieldDecl::anchor() { }
    971 
    972 ObjCAtDefsFieldDecl
    973 *ObjCAtDefsFieldDecl::Create(ASTContext &C, DeclContext *DC,
    974                              SourceLocation StartLoc,  SourceLocation IdLoc,
    975                              IdentifierInfo *Id, QualType T, Expr *BW) {
    976   return new (C) ObjCAtDefsFieldDecl(DC, StartLoc, IdLoc, Id, T, BW);
    977 }
    978 
    979 ObjCAtDefsFieldDecl *ObjCAtDefsFieldDecl::CreateDeserialized(ASTContext &C,
    980                                                              unsigned ID) {
    981   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCAtDefsFieldDecl));
    982   return new (Mem) ObjCAtDefsFieldDecl(0, SourceLocation(), SourceLocation(),
    983                                        0, QualType(), 0);
    984 }
    985 
    986 //===----------------------------------------------------------------------===//
    987 // ObjCProtocolDecl
    988 //===----------------------------------------------------------------------===//
    989 
    990 void ObjCProtocolDecl::anchor() { }
    991 
    992 ObjCProtocolDecl::ObjCProtocolDecl(DeclContext *DC, IdentifierInfo *Id,
    993                                    SourceLocation nameLoc,
    994                                    SourceLocation atStartLoc,
    995                                    ObjCProtocolDecl *PrevDecl)
    996   : ObjCContainerDecl(ObjCProtocol, DC, Id, nameLoc, atStartLoc), Data()
    997 {
    998   setPreviousDeclaration(PrevDecl);
    999   if (PrevDecl)
   1000     Data = PrevDecl->Data;
   1001 }
   1002 
   1003 ObjCProtocolDecl *ObjCProtocolDecl::Create(ASTContext &C, DeclContext *DC,
   1004                                            IdentifierInfo *Id,
   1005                                            SourceLocation nameLoc,
   1006                                            SourceLocation atStartLoc,
   1007                                            ObjCProtocolDecl *PrevDecl) {
   1008   ObjCProtocolDecl *Result
   1009     = new (C) ObjCProtocolDecl(DC, Id, nameLoc, atStartLoc, PrevDecl);
   1010 
   1011   return Result;
   1012 }
   1013 
   1014 ObjCProtocolDecl *ObjCProtocolDecl::CreateDeserialized(ASTContext &C,
   1015                                                        unsigned ID) {
   1016   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCProtocolDecl));
   1017   return new (Mem) ObjCProtocolDecl(0, 0, SourceLocation(), SourceLocation(),
   1018                                     0);
   1019 }
   1020 
   1021 ObjCProtocolDecl *ObjCProtocolDecl::lookupProtocolNamed(IdentifierInfo *Name) {
   1022   ObjCProtocolDecl *PDecl = this;
   1023 
   1024   if (Name == getIdentifier())
   1025     return PDecl;
   1026 
   1027   for (protocol_iterator I = protocol_begin(), E = protocol_end(); I != E; ++I)
   1028     if ((PDecl = (*I)->lookupProtocolNamed(Name)))
   1029       return PDecl;
   1030 
   1031   return NULL;
   1032 }
   1033 
   1034 // lookupMethod - Lookup a instance/class method in the protocol and protocols
   1035 // it inherited.
   1036 ObjCMethodDecl *ObjCProtocolDecl::lookupMethod(Selector Sel,
   1037                                                bool isInstance) const {
   1038   ObjCMethodDecl *MethodDecl = NULL;
   1039 
   1040   if ((MethodDecl = getMethod(Sel, isInstance)))
   1041     return MethodDecl;
   1042 
   1043   for (protocol_iterator I = protocol_begin(), E = protocol_end(); I != E; ++I)
   1044     if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance)))
   1045       return MethodDecl;
   1046   return NULL;
   1047 }
   1048 
   1049 void ObjCProtocolDecl::allocateDefinitionData() {
   1050   assert(!Data && "Protocol already has a definition!");
   1051   Data = new (getASTContext()) DefinitionData;
   1052   Data->Definition = this;
   1053 }
   1054 
   1055 void ObjCProtocolDecl::startDefinition() {
   1056   allocateDefinitionData();
   1057 
   1058   // Update all of the declarations with a pointer to the definition.
   1059   for (redecl_iterator RD = redecls_begin(), RDEnd = redecls_end();
   1060        RD != RDEnd; ++RD)
   1061     RD->Data = this->Data;
   1062 }
   1063 
   1064 //===----------------------------------------------------------------------===//
   1065 // ObjCCategoryDecl
   1066 //===----------------------------------------------------------------------===//
   1067 
   1068 void ObjCCategoryDecl::anchor() { }
   1069 
   1070 ObjCCategoryDecl *ObjCCategoryDecl::Create(ASTContext &C, DeclContext *DC,
   1071                                            SourceLocation AtLoc,
   1072                                            SourceLocation ClassNameLoc,
   1073                                            SourceLocation CategoryNameLoc,
   1074                                            IdentifierInfo *Id,
   1075                                            ObjCInterfaceDecl *IDecl,
   1076                                            SourceLocation IvarLBraceLoc,
   1077                                            SourceLocation IvarRBraceLoc) {
   1078   ObjCCategoryDecl *CatDecl = new (C) ObjCCategoryDecl(DC, AtLoc, ClassNameLoc,
   1079                                                        CategoryNameLoc, Id,
   1080                                                        IDecl,
   1081                                                        IvarLBraceLoc, IvarRBraceLoc);
   1082   if (IDecl) {
   1083     // Link this category into its class's category list.
   1084     CatDecl->NextClassCategory = IDecl->getCategoryList();
   1085     if (IDecl->hasDefinition()) {
   1086       IDecl->setCategoryList(CatDecl);
   1087       if (ASTMutationListener *L = C.getASTMutationListener())
   1088         L->AddedObjCCategoryToInterface(CatDecl, IDecl);
   1089     }
   1090   }
   1091 
   1092   return CatDecl;
   1093 }
   1094 
   1095 ObjCCategoryDecl *ObjCCategoryDecl::CreateDeserialized(ASTContext &C,
   1096                                                        unsigned ID) {
   1097   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCCategoryDecl));
   1098   return new (Mem) ObjCCategoryDecl(0, SourceLocation(), SourceLocation(),
   1099                                     SourceLocation(), 0, 0);
   1100 }
   1101 
   1102 ObjCCategoryImplDecl *ObjCCategoryDecl::getImplementation() const {
   1103   return getASTContext().getObjCImplementation(
   1104                                            const_cast<ObjCCategoryDecl*>(this));
   1105 }
   1106 
   1107 void ObjCCategoryDecl::setImplementation(ObjCCategoryImplDecl *ImplD) {
   1108   getASTContext().setObjCImplementation(this, ImplD);
   1109 }
   1110 
   1111 
   1112 //===----------------------------------------------------------------------===//
   1113 // ObjCCategoryImplDecl
   1114 //===----------------------------------------------------------------------===//
   1115 
   1116 void ObjCCategoryImplDecl::anchor() { }
   1117 
   1118 ObjCCategoryImplDecl *
   1119 ObjCCategoryImplDecl::Create(ASTContext &C, DeclContext *DC,
   1120                              IdentifierInfo *Id,
   1121                              ObjCInterfaceDecl *ClassInterface,
   1122                              SourceLocation nameLoc,
   1123                              SourceLocation atStartLoc,
   1124                              SourceLocation CategoryNameLoc) {
   1125   if (ClassInterface && ClassInterface->hasDefinition())
   1126     ClassInterface = ClassInterface->getDefinition();
   1127   return new (C) ObjCCategoryImplDecl(DC, Id, ClassInterface,
   1128                                       nameLoc, atStartLoc, CategoryNameLoc);
   1129 }
   1130 
   1131 ObjCCategoryImplDecl *ObjCCategoryImplDecl::CreateDeserialized(ASTContext &C,
   1132                                                                unsigned ID) {
   1133   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCCategoryImplDecl));
   1134   return new (Mem) ObjCCategoryImplDecl(0, 0, 0, SourceLocation(),
   1135                                         SourceLocation(), SourceLocation());
   1136 }
   1137 
   1138 ObjCCategoryDecl *ObjCCategoryImplDecl::getCategoryDecl() const {
   1139   // The class interface might be NULL if we are working with invalid code.
   1140   if (const ObjCInterfaceDecl *ID = getClassInterface())
   1141     return ID->FindCategoryDeclaration(getIdentifier());
   1142   return 0;
   1143 }
   1144 
   1145 
   1146 void ObjCImplDecl::anchor() { }
   1147 
   1148 void ObjCImplDecl::addPropertyImplementation(ObjCPropertyImplDecl *property) {
   1149   // FIXME: The context should be correct before we get here.
   1150   property->setLexicalDeclContext(this);
   1151   addDecl(property);
   1152 }
   1153 
   1154 void ObjCImplDecl::setClassInterface(ObjCInterfaceDecl *IFace) {
   1155   ASTContext &Ctx = getASTContext();
   1156 
   1157   if (ObjCImplementationDecl *ImplD
   1158         = dyn_cast_or_null<ObjCImplementationDecl>(this)) {
   1159     if (IFace)
   1160       Ctx.setObjCImplementation(IFace, ImplD);
   1161 
   1162   } else if (ObjCCategoryImplDecl *ImplD =
   1163              dyn_cast_or_null<ObjCCategoryImplDecl>(this)) {
   1164     if (ObjCCategoryDecl *CD = IFace->FindCategoryDeclaration(getIdentifier()))
   1165       Ctx.setObjCImplementation(CD, ImplD);
   1166   }
   1167 
   1168   ClassInterface = IFace;
   1169 }
   1170 
   1171 /// FindPropertyImplIvarDecl - This method lookup the ivar in the list of
   1172 /// properties implemented in this category @implementation block and returns
   1173 /// the implemented property that uses it.
   1174 ///
   1175 ObjCPropertyImplDecl *ObjCImplDecl::
   1176 FindPropertyImplIvarDecl(IdentifierInfo *ivarId) const {
   1177   for (propimpl_iterator i = propimpl_begin(), e = propimpl_end(); i != e; ++i){
   1178     ObjCPropertyImplDecl *PID = *i;
   1179     if (PID->getPropertyIvarDecl() &&
   1180         PID->getPropertyIvarDecl()->getIdentifier() == ivarId)
   1181       return PID;
   1182   }
   1183   return 0;
   1184 }
   1185 
   1186 /// FindPropertyImplDecl - This method looks up a previous ObjCPropertyImplDecl
   1187 /// added to the list of those properties @synthesized/@dynamic in this
   1188 /// category @implementation block.
   1189 ///
   1190 ObjCPropertyImplDecl *ObjCImplDecl::
   1191 FindPropertyImplDecl(IdentifierInfo *Id) const {
   1192   for (propimpl_iterator i = propimpl_begin(), e = propimpl_end(); i != e; ++i){
   1193     ObjCPropertyImplDecl *PID = *i;
   1194     if (PID->getPropertyDecl()->getIdentifier() == Id)
   1195       return PID;
   1196   }
   1197   return 0;
   1198 }
   1199 
   1200 raw_ostream &clang::operator<<(raw_ostream &OS,
   1201                                const ObjCCategoryImplDecl &CID) {
   1202   OS << CID.getName();
   1203   return OS;
   1204 }
   1205 
   1206 //===----------------------------------------------------------------------===//
   1207 // ObjCImplementationDecl
   1208 //===----------------------------------------------------------------------===//
   1209 
   1210 void ObjCImplementationDecl::anchor() { }
   1211 
   1212 ObjCImplementationDecl *
   1213 ObjCImplementationDecl::Create(ASTContext &C, DeclContext *DC,
   1214                                ObjCInterfaceDecl *ClassInterface,
   1215                                ObjCInterfaceDecl *SuperDecl,
   1216                                SourceLocation nameLoc,
   1217                                SourceLocation atStartLoc,
   1218                                SourceLocation IvarLBraceLoc,
   1219                                SourceLocation IvarRBraceLoc) {
   1220   if (ClassInterface && ClassInterface->hasDefinition())
   1221     ClassInterface = ClassInterface->getDefinition();
   1222   return new (C) ObjCImplementationDecl(DC, ClassInterface, SuperDecl,
   1223                                         nameLoc, atStartLoc,
   1224                                         IvarLBraceLoc, IvarRBraceLoc);
   1225 }
   1226 
   1227 ObjCImplementationDecl *
   1228 ObjCImplementationDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   1229   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCImplementationDecl));
   1230   return new (Mem) ObjCImplementationDecl(0, 0, 0, SourceLocation(),
   1231                                           SourceLocation());
   1232 }
   1233 
   1234 void ObjCImplementationDecl::setIvarInitializers(ASTContext &C,
   1235                                              CXXCtorInitializer ** initializers,
   1236                                                  unsigned numInitializers) {
   1237   if (numInitializers > 0) {
   1238     NumIvarInitializers = numInitializers;
   1239     CXXCtorInitializer **ivarInitializers =
   1240     new (C) CXXCtorInitializer*[NumIvarInitializers];
   1241     memcpy(ivarInitializers, initializers,
   1242            numInitializers * sizeof(CXXCtorInitializer*));
   1243     IvarInitializers = ivarInitializers;
   1244   }
   1245 }
   1246 
   1247 raw_ostream &clang::operator<<(raw_ostream &OS,
   1248                                const ObjCImplementationDecl &ID) {
   1249   OS << ID.getName();
   1250   return OS;
   1251 }
   1252 
   1253 //===----------------------------------------------------------------------===//
   1254 // ObjCCompatibleAliasDecl
   1255 //===----------------------------------------------------------------------===//
   1256 
   1257 void ObjCCompatibleAliasDecl::anchor() { }
   1258 
   1259 ObjCCompatibleAliasDecl *
   1260 ObjCCompatibleAliasDecl::Create(ASTContext &C, DeclContext *DC,
   1261                                 SourceLocation L,
   1262                                 IdentifierInfo *Id,
   1263                                 ObjCInterfaceDecl* AliasedClass) {
   1264   return new (C) ObjCCompatibleAliasDecl(DC, L, Id, AliasedClass);
   1265 }
   1266 
   1267 ObjCCompatibleAliasDecl *
   1268 ObjCCompatibleAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   1269   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCCompatibleAliasDecl));
   1270   return new (Mem) ObjCCompatibleAliasDecl(0, SourceLocation(), 0, 0);
   1271 }
   1272 
   1273 //===----------------------------------------------------------------------===//
   1274 // ObjCPropertyDecl
   1275 //===----------------------------------------------------------------------===//
   1276 
   1277 void ObjCPropertyDecl::anchor() { }
   1278 
   1279 ObjCPropertyDecl *ObjCPropertyDecl::Create(ASTContext &C, DeclContext *DC,
   1280                                            SourceLocation L,
   1281                                            IdentifierInfo *Id,
   1282                                            SourceLocation AtLoc,
   1283                                            SourceLocation LParenLoc,
   1284                                            TypeSourceInfo *T,
   1285                                            PropertyControl propControl) {
   1286   return new (C) ObjCPropertyDecl(DC, L, Id, AtLoc, LParenLoc, T);
   1287 }
   1288 
   1289 ObjCPropertyDecl *ObjCPropertyDecl::CreateDeserialized(ASTContext &C,
   1290                                                        unsigned ID) {
   1291   void * Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCPropertyDecl));
   1292   return new (Mem) ObjCPropertyDecl(0, SourceLocation(), 0, SourceLocation(),
   1293                                     SourceLocation(),
   1294                                     0);
   1295 }
   1296 
   1297 //===----------------------------------------------------------------------===//
   1298 // ObjCPropertyImplDecl
   1299 //===----------------------------------------------------------------------===//
   1300 
   1301 ObjCPropertyImplDecl *ObjCPropertyImplDecl::Create(ASTContext &C,
   1302                                                    DeclContext *DC,
   1303                                                    SourceLocation atLoc,
   1304                                                    SourceLocation L,
   1305                                                    ObjCPropertyDecl *property,
   1306                                                    Kind PK,
   1307                                                    ObjCIvarDecl *ivar,
   1308                                                    SourceLocation ivarLoc) {
   1309   return new (C) ObjCPropertyImplDecl(DC, atLoc, L, property, PK, ivar,
   1310                                       ivarLoc);
   1311 }
   1312 
   1313 ObjCPropertyImplDecl *ObjCPropertyImplDecl::CreateDeserialized(ASTContext &C,
   1314                                                                unsigned ID) {
   1315   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCPropertyImplDecl));
   1316   return new (Mem) ObjCPropertyImplDecl(0, SourceLocation(), SourceLocation(),
   1317                                         0, Dynamic, 0, SourceLocation());
   1318 }
   1319 
   1320 SourceRange ObjCPropertyImplDecl::getSourceRange() const {
   1321   SourceLocation EndLoc = getLocation();
   1322   if (IvarLoc.isValid())
   1323     EndLoc = IvarLoc;
   1324 
   1325   return SourceRange(AtLoc, EndLoc);
   1326 }
   1327