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

   1 //===--- DeclObjC.cpp - ObjC Declaration AST Node Implementation ----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the Objective-C related Decl classes.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/AST/DeclObjC.h"
  15 #include "clang/AST/ASTContext.h"
  16 #include "clang/AST/ASTMutationListener.h"
  17 #include "clang/AST/Attr.h"
  18 #include "clang/AST/Stmt.h"
  19 #include "llvm/ADT/STLExtras.h"
  20 #include "llvm/ADT/SmallString.h"
  21 using namespace clang;
  22
  23 //===----------------------------------------------------------------------===//
  24 // ObjCListBase
  25 //===----------------------------------------------------------------------===//
  26
  27 void ObjCListBase::set(void *const* InList, unsigned Elts, ASTContext &Ctx) {
  28   List = 0;
  29   if (Elts == 0) return;  // Setting to an empty list is a noop.
  30
  31
  32   List = new (Ctx) void*[Elts];
  33   NumElts = Elts;
  34   memcpy(List, InList, sizeof(void*)*Elts);
  35 }
  36
  37 void ObjCProtocolList::set(ObjCProtocolDecl* const* InList, unsigned Elts,
  38                            const SourceLocation *Locs, ASTContext &Ctx) {
  39   if (Elts == 0)
  40     return;
  41
  42   Locations = new (Ctx) SourceLocation[Elts];
  43   memcpy(Locations, Locs, sizeof(SourceLocation) * Elts);
  44   set(InList, Elts, Ctx);
  45 }
  46
  47 //===----------------------------------------------------------------------===//
  48 // ObjCInterfaceDecl
  49 //===----------------------------------------------------------------------===//
  50
  51 void ObjCContainerDecl::anchor() { }
  52
  53 /// getIvarDecl - This method looks up an ivar in this ContextDecl.
  54 ///
  55 ObjCIvarDecl *
  56 ObjCContainerDecl::getIvarDecl(IdentifierInfo *Id) const {
  57   lookup_const_result R = lookup(Id);
  58   for (lookup_const_iterator Ivar = R.begin(), IvarEnd = R.end();
  59        Ivar != IvarEnd; ++Ivar) {
  60     if (ObjCIvarDecl *ivar = dyn_cast<ObjCIvarDecl>(*Ivar))
  61       return ivar;
  62   }
  63   return 0;
  64 }
  65
  66 // Get the local instance/class method declared in this interface.
  67 ObjCMethodDecl *
  68 ObjCContainerDecl::getMethod(Selector Sel, bool isInstance,
  69                              bool AllowHidden) const {
  70   // If this context is a hidden protocol definition, don't find any
  71   // methods there.
  72   if (const ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(this)) {
  73     if (const ObjCProtocolDecl *Def = Proto->getDefinition())
  74       if (Def->isHidden() && !AllowHidden)
  75         return 0;
  76   }
  77
  78   // Since instance & class methods can have the same name, the loop below
  79   // ensures we get the correct method.
  80   //
  81   // @interface Whatever
  82   // - (int) class_method;
  83   // + (float) class_method;
  84   // @end
  85   //
  86   lookup_const_result R = lookup(Sel);
  87   for (lookup_const_iterator Meth = R.begin(), MethEnd = R.end();
  88        Meth != MethEnd; ++Meth) {
  89     ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(*Meth);
  90     if (MD && MD->isInstanceMethod() == isInstance)
  91       return MD;
  92   }
  93   return 0;
  94 }
  95
  96 /// HasUserDeclaredSetterMethod - This routine returns 'true' if a user declared setter
  97 /// method was found in the class, its protocols, its super classes or categories.
  98 /// It also returns 'true' if one of its categories has declared a 'readwrite' property.
  99 /// This is because, user must provide a setter method for the category's 'readwrite'
 100 /// property.
 101 bool
 102 ObjCContainerDecl::HasUserDeclaredSetterMethod(const ObjCPropertyDecl *Property) const {
 103   Selector Sel = Property->getSetterName();
 104   lookup_const_result R = lookup(Sel);
 105   for (lookup_const_iterator Meth = R.begin(), MethEnd = R.end();
 106        Meth != MethEnd; ++Meth) {
 107     ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(*Meth);
 108     if (MD && MD->isInstanceMethod() && !MD->isImplicit())
 109       return true;
 110   }
 111
 112   if (const ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(this)) {
 113     // Also look into categories, including class extensions, looking
 114     // for a user declared instance method.
 115     for (ObjCInterfaceDecl::visible_categories_iterator
 116          Cat = ID->visible_categories_begin(),
 117          CatEnd = ID->visible_categories_end();
 118          Cat != CatEnd;
 119          ++Cat) {
 120       if (ObjCMethodDecl *MD = Cat->getInstanceMethod(Sel))
 121         if (!MD->isImplicit())
 122           return true;
 123       if (Cat->IsClassExtension())
 124         continue;
 125       // Also search through the categories looking for a 'readwrite' declaration
 126       // of this property. If one found, presumably a setter will be provided
 127       // (properties declared in categories will not get auto-synthesized).
 128       for (ObjCContainerDecl::prop_iterator P = Cat->prop_begin(),
 129            E = Cat->prop_end(); P != E; ++P)
 130         if (P->getIdentifier() == Property->getIdentifier()) {
 131           if (P->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_readwrite)
 132             return true;
 133           break;
 134         }
 135     }
 136
 137     // Also look into protocols, for a user declared instance method.
 138     for (ObjCInterfaceDecl::all_protocol_iterator P =
 139          ID->all_referenced_protocol_begin(),
 140          PE = ID->all_referenced_protocol_end(); P != PE; ++P) {
 141       ObjCProtocolDecl *Proto = (*P);
 142       if (Proto->HasUserDeclaredSetterMethod(Property))
 143         return true;
 144     }
 145     // And in its super class.
 146     ObjCInterfaceDecl *OSC = ID->getSuperClass();
 147     while (OSC) {
 148       if (OSC->HasUserDeclaredSetterMethod(Property))
 149         return true;
 150       OSC = OSC->getSuperClass();
 151     }
 152   }
 153   if (const ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(this))
 154     for (ObjCProtocolDecl::protocol_iterator PI = PD->protocol_begin(),
 155          E = PD->protocol_end(); PI != E; ++PI) {
 156       if ((*PI)->HasUserDeclaredSetterMethod(Property))
 157         return true;
 158     }
 159   return false;
 160 }
 161
 162 ObjCPropertyDecl *
 163 ObjCPropertyDecl::findPropertyDecl(const DeclContext *DC,
 164                                    IdentifierInfo *propertyID) {
 165   // If this context is a hidden protocol definition, don't find any
 166   // property.
 167   if (const ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(DC)) {
 168     if (const ObjCProtocolDecl *Def = Proto->getDefinition())
 169       if (Def->isHidden())
 170         return 0;
 171   }
 172
 173   DeclContext::lookup_const_result R = DC->lookup(propertyID);
 174   for (DeclContext::lookup_const_iterator I = R.begin(), E = R.end(); I != E;
 175        ++I)
 176     if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(*I))
 177       return PD;
 178
 179   return 0;
 180 }
 181
 182 IdentifierInfo *
 183 ObjCPropertyDecl::getDefaultSynthIvarName(ASTContext &Ctx) const {
 184   SmallString<128> ivarName;
 185   {
 186     llvm::raw_svector_ostream os(ivarName);
 187     os << '_' << getIdentifier()->getName();
 188   }
 189   return &Ctx.Idents.get(ivarName.str());
 190 }
 191
 192 /// FindPropertyDeclaration - Finds declaration of the property given its name
 193 /// in 'PropertyId' and returns it. It returns 0, if not found.
 194 ObjCPropertyDecl *
 195 ObjCContainerDecl::FindPropertyDeclaration(IdentifierInfo *PropertyId) const {
 196   // Don't find properties within hidden protocol definitions.
 197   if (const ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(this)) {
 198     if (const ObjCProtocolDecl *Def = Proto->getDefinition())
 199       if (Def->isHidden())
 200         return 0;
 201   }
 202
 203   if (ObjCPropertyDecl *PD =
 204         ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(this), PropertyId))
 205     return PD;
 206
 207   switch (getKind()) {
 208     default:
 209       break;
 210     case Decl::ObjCProtocol: {
 211       const ObjCProtocolDecl *PID = cast<ObjCProtocolDecl>(this);
 212       for (ObjCProtocolDecl::protocol_iterator I = PID->protocol_begin(),
 213            E = PID->protocol_end(); I != E; ++I)
 214         if (ObjCPropertyDecl *P = (*I)->FindPropertyDeclaration(PropertyId))
 215           return P;
 216       break;
 217     }
 218     case Decl::ObjCInterface: {
 219       const ObjCInterfaceDecl *OID = cast<ObjCInterfaceDecl>(this);
 220       // Look through categories (but not extensions).
 221       for (ObjCInterfaceDecl::visible_categories_iterator
 222              Cat = OID->visible_categories_begin(),
 223              CatEnd = OID->visible_categories_end();
 224            Cat != CatEnd; ++Cat) {
 225         if (!Cat->IsClassExtension())
 226           if (ObjCPropertyDecl *P = Cat->FindPropertyDeclaration(PropertyId))
 227             return P;
 228       }
 229
 230       // Look through protocols.
 231       for (ObjCInterfaceDecl::all_protocol_iterator
 232             I = OID->all_referenced_protocol_begin(),
 233             E = OID->all_referenced_protocol_end(); I != E; ++I)
 234         if (ObjCPropertyDecl *P = (*I)->FindPropertyDeclaration(PropertyId))
 235           return P;
 236
 237       // Finally, check the super class.
 238       if (const ObjCInterfaceDecl *superClass = OID->getSuperClass())
 239         return superClass->FindPropertyDeclaration(PropertyId);
 240       break;
 241     }
 242     case Decl::ObjCCategory: {
 243       const ObjCCategoryDecl *OCD = cast<ObjCCategoryDecl>(this);
 244       // Look through protocols.
 245       if (!OCD->IsClassExtension())
 246         for (ObjCCategoryDecl::protocol_iterator
 247               I = OCD->protocol_begin(), E = OCD->protocol_end(); I != E; ++I)
 248         if (ObjCPropertyDecl *P = (*I)->FindPropertyDeclaration(PropertyId))
 249           return P;
 250
 251       break;
 252     }
 253   }
 254   return 0;
 255 }
 256
 257 void ObjCInterfaceDecl::anchor() { }
 258
 259 /// FindPropertyVisibleInPrimaryClass - Finds declaration of the property
 260 /// with name 'PropertyId' in the primary class; including those in protocols
 261 /// (direct or indirect) used by the primary class.
 262 ///
 263 ObjCPropertyDecl *
 264 ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass(
 265                                             IdentifierInfo *PropertyId) const {
 266   // FIXME: Should make sure no callers ever do this.
 267   if (!hasDefinition())
 268     return 0;
 269
 270   if (data().ExternallyCompleted)
 271     LoadExternalDefinition();
 272
 273   if (ObjCPropertyDecl *PD =
 274       ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(this), PropertyId))
 275     return PD;
 276
 277   // Look through protocols.
 278   for (ObjCInterfaceDecl::all_protocol_iterator
 279         I = all_referenced_protocol_begin(),
 280         E = all_referenced_protocol_end(); I != E; ++I)
 281     if (ObjCPropertyDecl *P = (*I)->FindPropertyDeclaration(PropertyId))
 282       return P;
 283
 284   return 0;
 285 }
 286
 287 void ObjCInterfaceDecl::collectPropertiesToImplement(PropertyMap &PM,
 288                                                      PropertyDeclOrder &PO) const {
 289   for (ObjCContainerDecl::prop_iterator P = prop_begin(),
 290       E = prop_end(); P != E; ++P) {
 291     ObjCPropertyDecl *Prop = *P;
 292     PM[Prop->getIdentifier()] = Prop;
 293     PO.push_back(Prop);
 294   }
 295   for (ObjCInterfaceDecl::all_protocol_iterator
 296       PI = all_referenced_protocol_begin(),
 297       E = all_referenced_protocol_end(); PI != E; ++PI)
 298     (*PI)->collectPropertiesToImplement(PM, PO);
 299   // Note, the properties declared only in class extensions are still copied
 300   // into the main @interface's property list, and therefore we don't
 301   // explicitly, have to search class extension properties.
 302 }
 303
 304 bool ObjCInterfaceDecl::isArcWeakrefUnavailable() const {
 305   const ObjCInterfaceDecl *Class = this;
 306   while (Class) {
 307     if (Class->hasAttr<ArcWeakrefUnavailableAttr>())
 308       return true;
 309     Class = Class->getSuperClass();
 310   }
 311   return false;
 312 }
 313
 314 const ObjCInterfaceDecl *ObjCInterfaceDecl::isObjCRequiresPropertyDefs() const {
 315   const ObjCInterfaceDecl *Class = this;
 316   while (Class) {
 317     if (Class->hasAttr<ObjCRequiresPropertyDefsAttr>())
 318       return Class;
 319     Class = Class->getSuperClass();
 320   }
 321   return 0;
 322 }
 323
 324 void ObjCInterfaceDecl::mergeClassExtensionProtocolList(
 325                               ObjCProtocolDecl *const* ExtList, unsigned ExtNum,
 326                               ASTContext &C)
 327 {
 328   if (data().ExternallyCompleted)
 329     LoadExternalDefinition();
 330
 331   if (data().AllReferencedProtocols.empty() &&
 332       data().ReferencedProtocols.empty()) {
 333     data().AllReferencedProtocols.set(ExtList, ExtNum, C);
 334     return;
 335   }
 336
 337   // Check for duplicate protocol in class's protocol list.
 338   // This is O(n*m). But it is extremely rare and number of protocols in
 339   // class or its extension are very few.
 340   SmallVector<ObjCProtocolDecl*, 8> ProtocolRefs;
 341   for (unsigned i = 0; i < ExtNum; i++) {
 342     bool protocolExists = false;
 343     ObjCProtocolDecl *ProtoInExtension = ExtList[i];
 344     for (all_protocol_iterator
 345           p = all_referenced_protocol_begin(),
 346           e = all_referenced_protocol_end(); p != e; ++p) {
 347       ObjCProtocolDecl *Proto = (*p);
 348       if (C.ProtocolCompatibleWithProtocol(ProtoInExtension, Proto)) {
 349         protocolExists = true;
 350         break;
 351       }
 352     }
 353     // Do we want to warn on a protocol in extension class which
 354     // already exist in the class? Probably not.
 355     if (!protocolExists)
 356       ProtocolRefs.push_back(ProtoInExtension);
 357   }
 358
 359   if (ProtocolRefs.empty())
 360     return;
 361
 362   // Merge ProtocolRefs into class's protocol list;
 363   for (all_protocol_iterator p = all_referenced_protocol_begin(),
 364         e = all_referenced_protocol_end(); p != e; ++p) {
 365     ProtocolRefs.push_back(*p);
 366   }
 367
 368   data().AllReferencedProtocols.set(ProtocolRefs.data(), ProtocolRefs.size(),C);
 369 }
 370
 371 void ObjCInterfaceDecl::allocateDefinitionData() {
 372   assert(!hasDefinition() && "ObjC class already has a definition");
 373   Data.setPointer(new (getASTContext()) DefinitionData());
 374   Data.getPointer()->Definition = this;
 375
 376   // Make the type point at the definition, now that we have one.
 377   if (TypeForDecl)
 378     cast<ObjCInterfaceType>(TypeForDecl)->Decl = this;
 379 }
 380
 381 void ObjCInterfaceDecl::startDefinition() {
 382   allocateDefinitionData();
 383
 384   // Update all of the declarations with a pointer to the definition.
 385   for (redecl_iterator RD = redecls_begin(), RDEnd = redecls_end();
 386        RD != RDEnd; ++RD) {
 387     if (*RD != this)
 388       RD->Data = Data;
 389   }
 390 }
 391
 392 ObjCIvarDecl *ObjCInterfaceDecl::lookupInstanceVariable(IdentifierInfo *ID,
 393                                               ObjCInterfaceDecl *&clsDeclared) {
 394   // FIXME: Should make sure no callers ever do this.
 395   if (!hasDefinition())
 396     return 0;
 397
 398   if (data().ExternallyCompleted)
 399     LoadExternalDefinition();
 400
 401   ObjCInterfaceDecl* ClassDecl = this;
 402   while (ClassDecl != NULL) {
 403     if (ObjCIvarDecl *I = ClassDecl->getIvarDecl(ID)) {
 404       clsDeclared = ClassDecl;
 405       return I;
 406     }
 407
 408     for (ObjCInterfaceDecl::visible_extensions_iterator
 409            Ext = ClassDecl->visible_extensions_begin(),
 410            ExtEnd = ClassDecl->visible_extensions_end();
 411          Ext != ExtEnd; ++Ext) {
 412       if (ObjCIvarDecl *I = Ext->getIvarDecl(ID)) {
 413         clsDeclared = ClassDecl;
 414         return I;
 415       }
 416     }
 417
 418     ClassDecl = ClassDecl->getSuperClass();
 419   }
 420   return NULL;
 421 }
 422
 423 /// lookupInheritedClass - This method returns ObjCInterfaceDecl * of the super
 424 /// class whose name is passed as argument. If it is not one of the super classes
 425 /// the it returns NULL.
 426 ObjCInterfaceDecl *ObjCInterfaceDecl::lookupInheritedClass(
 427                                         const IdentifierInfo*ICName) {
 428   // FIXME: Should make sure no callers ever do this.
 429   if (!hasDefinition())
 430     return 0;
 431
 432   if (data().ExternallyCompleted)
 433     LoadExternalDefinition();
 434
 435   ObjCInterfaceDecl* ClassDecl = this;
 436   while (ClassDecl != NULL) {
 437     if (ClassDecl->getIdentifier() == ICName)
 438       return ClassDecl;
 439     ClassDecl = ClassDecl->getSuperClass();
 440   }
 441   return NULL;
 442 }
 443
 444 ObjCProtocolDecl *
 445 ObjCInterfaceDecl::lookupNestedProtocol(IdentifierInfo *Name) {
 446   for (ObjCInterfaceDecl::all_protocol_iterator P =
 447        all_referenced_protocol_begin(), PE = all_referenced_protocol_end();
 448        P != PE; ++P)
 449     if ((*P)->lookupProtocolNamed(Name))
 450       return (*P);
 451   ObjCInterfaceDecl *SuperClass = getSuperClass();
 452   return SuperClass ? SuperClass->lookupNestedProtocol(Name) : NULL;
 453 }
 454
 455 /// lookupMethod - This method returns an instance/class method by looking in
 456 /// the class, its categories, and its super classes (using a linear search).
 457 /// When argument category "C" is specified, any implicit method found
 458 /// in this category is ignored.
 459 ObjCMethodDecl *ObjCInterfaceDecl::lookupMethod(Selector Sel,
 460                                      bool isInstance,
 461                                      bool shallowCategoryLookup,
 462                                      const ObjCCategoryDecl *C) const {
 463   // FIXME: Should make sure no callers ever do this.
 464   if (!hasDefinition())
 465     return 0;
 466
 467   const ObjCInterfaceDecl* ClassDecl = this;
 468   ObjCMethodDecl *MethodDecl = 0;
 469
 470   if (data().ExternallyCompleted)
 471     LoadExternalDefinition();
 472
 473   while (ClassDecl != NULL) {
 474     if ((MethodDecl = ClassDecl->getMethod(Sel, isInstance)))
 475       return MethodDecl;
 476
 477     // Didn't find one yet - look through protocols.
 478     for (ObjCInterfaceDecl::protocol_iterator I = ClassDecl->protocol_begin(),
 479                                               E = ClassDecl->protocol_end();
 480            I != E; ++I)
 481       if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance)))
 482         return MethodDecl;
 483
 484     // Didn't find one yet - now look through categories.
 485     for (ObjCInterfaceDecl::visible_categories_iterator
 486          Cat = ClassDecl->visible_categories_begin(),
 487          CatEnd = ClassDecl->visible_categories_end();
 488          Cat != CatEnd; ++Cat) {
 489       if ((MethodDecl = Cat->getMethod(Sel, isInstance)))
 490         if (C != (*Cat) || !MethodDecl->isImplicit())
 491           return MethodDecl;
 492
 493       if (!shallowCategoryLookup) {
 494         // Didn't find one yet - look through protocols.
 495         const ObjCList<ObjCProtocolDecl> &Protocols =
 496         Cat->getReferencedProtocols();
 497         for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
 498              E = Protocols.end(); I != E; ++I)
 499           if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance)))
 500             if (C != (*Cat) || !MethodDecl->isImplicit())
 501               return MethodDecl;
 502       }
 503     }
 504
 505     ClassDecl = ClassDecl->getSuperClass();
 506   }
 507   return NULL;
 508 }
 509
 510 // Will search "local" class/category implementations for a method decl.
 511 // If failed, then we search in class's root for an instance method.
 512 // Returns 0 if no method is found.
 513 ObjCMethodDecl *ObjCInterfaceDecl::lookupPrivateMethod(
 514                                    const Selector &Sel,
 515                                    bool Instance) const {
 516   // FIXME: Should make sure no callers ever do this.
 517   if (!hasDefinition())
 518     return 0;
 519
 520   if (data().ExternallyCompleted)
 521     LoadExternalDefinition();
 522
 523   ObjCMethodDecl *Method = 0;
 524   if (ObjCImplementationDecl *ImpDecl = getImplementation())
 525     Method = Instance ? ImpDecl->getInstanceMethod(Sel)
 526                       : ImpDecl->getClassMethod(Sel);
 527
 528   // Look through local category implementations associated with the class.
 529   if (!Method)
 530     Method = Instance ? getCategoryInstanceMethod(Sel)
 531                       : getCategoryClassMethod(Sel);
 532
 533   // Before we give up, check if the selector is an instance method.
 534   // But only in the root. This matches gcc's behavior and what the
 535   // runtime expects.
 536   if (!Instance && !Method && !getSuperClass()) {
 537     Method = lookupInstanceMethod(Sel);
 538     // Look through local category implementations associated
 539     // with the root class.
 540     if (!Method)
 541       Method = lookupPrivateMethod(Sel, true);
 542   }
 543
 544   if (!Method && getSuperClass())
 545     return getSuperClass()->lookupPrivateMethod(Sel, Instance);
 546   return Method;
 547 }
 548
 549 //===----------------------------------------------------------------------===//
 550 // ObjCMethodDecl
 551 //===----------------------------------------------------------------------===//
 552
 553 ObjCMethodDecl *ObjCMethodDecl::Create(ASTContext &C,
 554                                        SourceLocation beginLoc,
 555                                        SourceLocation endLoc,
 556                                        Selector SelInfo, QualType T,
 557                                        TypeSourceInfo *ResultTInfo,
 558                                        DeclContext *contextDecl,
 559                                        bool isInstance,
 560                                        bool isVariadic,
 561                                        bool isPropertyAccessor,
 562                                        bool isImplicitlyDeclared,
 563                                        bool isDefined,
 564                                        ImplementationControl impControl,
 565                                        bool HasRelatedResultType) {
 566   return new (C) ObjCMethodDecl(beginLoc, endLoc,
 567                                 SelInfo, T, ResultTInfo, contextDecl,
 568                                 isInstance, isVariadic, isPropertyAccessor,
 569                                 isImplicitlyDeclared, isDefined,
 570                                 impControl,
 571                                 HasRelatedResultType);
 572 }
 573
 574 ObjCMethodDecl *ObjCMethodDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
 575   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCMethodDecl));
 576   return new (Mem) ObjCMethodDecl(SourceLocation(), SourceLocation(),
 577                                   Selector(), QualType(), 0, 0);
 578 }
 579
 580 Stmt *ObjCMethodDecl::getBody() const {
 581   return Body.get(getASTContext().getExternalSource());
 582 }
 583
 584 void ObjCMethodDecl::setAsRedeclaration(const ObjCMethodDecl *PrevMethod) {
 585   assert(PrevMethod);
 586   getASTContext().setObjCMethodRedeclaration(PrevMethod, this);
 587   IsRedeclaration = true;
 588   PrevMethod->HasRedeclaration = true;
 589 }
 590
 591 void ObjCMethodDecl::setParamsAndSelLocs(ASTContext &C,
 592                                          ArrayRef<ParmVarDecl*> Params,
 593                                          ArrayRef<SourceLocation> SelLocs) {
 594   ParamsAndSelLocs = 0;
 595   NumParams = Params.size();
 596   if (Params.empty() && SelLocs.empty())
 597     return;
 598
 599   unsigned Size = sizeof(ParmVarDecl *) * NumParams +
 600                   sizeof(SourceLocation) * SelLocs.size();
 601   ParamsAndSelLocs = C.Allocate(Size);
 602   std::copy(Params.begin(), Params.end(), getParams());
 603   std::copy(SelLocs.begin(), SelLocs.end(), getStoredSelLocs());
 604 }
 605
 606 void ObjCMethodDecl::getSelectorLocs(
 607                                SmallVectorImpl<SourceLocation> &SelLocs) const {
 608   for (unsigned i = 0, e = getNumSelectorLocs(); i != e; ++i)
 609     SelLocs.push_back(getSelectorLoc(i));
 610 }
 611
 612 void ObjCMethodDecl::setMethodParams(ASTContext &C,
 613                                      ArrayRef<ParmVarDecl*> Params,
 614                                      ArrayRef<SourceLocation> SelLocs) {
 615   assert((!SelLocs.empty() || isImplicit()) &&
 616          "No selector locs for non-implicit method");
 617   if (isImplicit())
 618     return setParamsAndSelLocs(C, Params, llvm::None);
 619
 620   SelLocsKind = hasStandardSelectorLocs(getSelector(), SelLocs, Params,
 621                                         DeclEndLoc);
 622   if (SelLocsKind != SelLoc_NonStandard)
 623     return setParamsAndSelLocs(C, Params, llvm::None);
 624
 625   setParamsAndSelLocs(C, Params, SelLocs);
 626 }
 627
 628 /// \brief A definition will return its interface declaration.
 629 /// An interface declaration will return its definition.
 630 /// Otherwise it will return itself.
 631 ObjCMethodDecl *ObjCMethodDecl::getNextRedeclaration() {
 632   ASTContext &Ctx = getASTContext();
 633   ObjCMethodDecl *Redecl = 0;
 634   if (HasRedeclaration)
 635     Redecl = const_cast<ObjCMethodDecl*>(Ctx.getObjCMethodRedeclaration(this));
 636   if (Redecl)
 637     return Redecl;
 638
 639   Decl *CtxD = cast<Decl>(getDeclContext());
 640
 641   if (!CtxD->isInvalidDecl()) {
 642     if (ObjCInterfaceDecl *IFD = dyn_cast<ObjCInterfaceDecl>(CtxD)) {
 643       if (ObjCImplementationDecl *ImplD = Ctx.getObjCImplementation(IFD))
 644         if (!ImplD->isInvalidDecl())
 645           Redecl = ImplD->getMethod(getSelector(), isInstanceMethod());
 646
 647     } else if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CtxD)) {
 648       if (ObjCCategoryImplDecl *ImplD = Ctx.getObjCImplementation(CD))
 649         if (!ImplD->isInvalidDecl())
 650           Redecl = ImplD->getMethod(getSelector(), isInstanceMethod());
 651
 652     } else if (ObjCImplementationDecl *ImplD =
 653                  dyn_cast<ObjCImplementationDecl>(CtxD)) {
 654       if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
 655         if (!IFD->isInvalidDecl())
 656           Redecl = IFD->getMethod(getSelector(), isInstanceMethod());
 657
 658     } else if (ObjCCategoryImplDecl *CImplD =
 659                  dyn_cast<ObjCCategoryImplDecl>(CtxD)) {
 660       if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl())
 661         if (!CatD->isInvalidDecl())
 662           Redecl = CatD->getMethod(getSelector(), isInstanceMethod());
 663     }
 664   }
 665
 666   if (!Redecl && isRedeclaration()) {
 667     // This is the last redeclaration, go back to the first method.
 668     return cast<ObjCContainerDecl>(CtxD)->getMethod(getSelector(),
 669                                                     isInstanceMethod());
 670   }
 671
 672   return Redecl ? Redecl : this;
 673 }
 674
 675 ObjCMethodDecl *ObjCMethodDecl::getCanonicalDecl() {
 676   Decl *CtxD = cast<Decl>(getDeclContext());
 677
 678   if (ObjCImplementationDecl *ImplD = dyn_cast<ObjCImplementationDecl>(CtxD)) {
 679     if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
 680       if (ObjCMethodDecl *MD = IFD->getMethod(getSelector(),
 681                                               isInstanceMethod()))
 682         return MD;
 683
 684   } else if (ObjCCategoryImplDecl *CImplD =
 685                dyn_cast<ObjCCategoryImplDecl>(CtxD)) {
 686     if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl())
 687       if (ObjCMethodDecl *MD = CatD->getMethod(getSelector(),
 688                                                isInstanceMethod()))
 689         return MD;
 690   }
 691
 692   if (isRedeclaration())
 693     return cast<ObjCContainerDecl>(CtxD)->getMethod(getSelector(),
 694                                                     isInstanceMethod());
 695
 696   return this;
 697 }
 698
 699 SourceLocation ObjCMethodDecl::getLocEnd() const {
 700   if (Stmt *Body = getBody())
 701     return Body->getLocEnd();
 702   return DeclEndLoc;
 703 }
 704
 705 ObjCMethodFamily ObjCMethodDecl::getMethodFamily() const {
 706   ObjCMethodFamily family = static_cast<ObjCMethodFamily>(Family);
 707   if (family != static_cast<unsigned>(InvalidObjCMethodFamily))
 708     return family;
 709
 710   // Check for an explicit attribute.
 711   if (const ObjCMethodFamilyAttr *attr = getAttr<ObjCMethodFamilyAttr>()) {
 712     // The unfortunate necessity of mapping between enums here is due
 713     // to the attributes framework.
 714     switch (attr->getFamily()) {
 715     case ObjCMethodFamilyAttr::OMF_None: family = OMF_None; break;
 716     case ObjCMethodFamilyAttr::OMF_alloc: family = OMF_alloc; break;
 717     case ObjCMethodFamilyAttr::OMF_copy: family = OMF_copy; break;
 718     case ObjCMethodFamilyAttr::OMF_init: family = OMF_init; break;
 719     case ObjCMethodFamilyAttr::OMF_mutableCopy: family = OMF_mutableCopy; break;
 720     case ObjCMethodFamilyAttr::OMF_new: family = OMF_new; break;
 721     }
 722     Family = static_cast<unsigned>(family);
 723     return family;
 724   }
 725
 726   family = getSelector().getMethodFamily();
 727   switch (family) {
 728   case OMF_None: break;
 729
 730   // init only has a conventional meaning for an instance method, and
 731   // it has to return an object.
 732   case OMF_init:
 733     if (!isInstanceMethod() || !getResultType()->isObjCObjectPointerType())
 734       family = OMF_None;
 735     break;
 736
 737   // alloc/copy/new have a conventional meaning for both class and
 738   // instance methods, but they require an object return.
 739   case OMF_alloc:
 740   case OMF_copy:
 741   case OMF_mutableCopy:
 742   case OMF_new:
 743     if (!getResultType()->isObjCObjectPointerType())
 744       family = OMF_None;
 745     break;
 746
 747   // These selectors have a conventional meaning only for instance methods.
 748   case OMF_dealloc:
 749   case OMF_finalize:
 750   case OMF_retain:
 751   case OMF_release:
 752   case OMF_autorelease:
 753   case OMF_retainCount:
 754   case OMF_self:
 755     if (!isInstanceMethod())
 756       family = OMF_None;
 757     break;
 758
 759   case OMF_performSelector:
 760     if (!isInstanceMethod() ||
 761         !getResultType()->isObjCIdType())
 762       family = OMF_None;
 763     else {
 764       unsigned noParams = param_size();
 765       if (noParams < 1 || noParams > 3)
 766         family = OMF_None;
 767       else {
 768         ObjCMethodDecl::arg_type_iterator it = arg_type_begin();
 769         QualType ArgT = (*it);
 770         if (!ArgT->isObjCSelType()) {
 771           family = OMF_None;
 772           break;
 773         }
 774         while (--noParams) {
 775           it++;
 776           ArgT = (*it);
 777           if (!ArgT->isObjCIdType()) {
 778             family = OMF_None;
 779             break;
 780           }
 781         }
 782       }
 783     }
 784     break;
 785
 786   }
 787
 788   // Cache the result.
 789   Family = static_cast<unsigned>(family);
 790   return family;
 791 }
 792
 793 void ObjCMethodDecl::createImplicitParams(ASTContext &Context,
 794                                           const ObjCInterfaceDecl *OID) {
 795   QualType selfTy;
 796   if (isInstanceMethod()) {
 797     // There may be no interface context due to error in declaration
 798     // of the interface (which has been reported). Recover gracefully.
 799     if (OID) {
 800       selfTy = Context.getObjCInterfaceType(OID);
 801       selfTy = Context.getObjCObjectPointerType(selfTy);
 802     } else {
 803       selfTy = Context.getObjCIdType();
 804     }
 805   } else // we have a factory method.
 806     selfTy = Context.getObjCClassType();
 807
 808   bool selfIsPseudoStrong = false;
 809   bool selfIsConsumed = false;
 810
 811   if (Context.getLangOpts().ObjCAutoRefCount) {
 812     if (isInstanceMethod()) {
 813       selfIsConsumed = hasAttr<NSConsumesSelfAttr>();
 814
 815       // 'self' is always __strong.  It's actually pseudo-strong except
 816       // in init methods (or methods labeled ns_consumes_self), though.
 817       Qualifiers qs;
 818       qs.setObjCLifetime(Qualifiers::OCL_Strong);
 819       selfTy = Context.getQualifiedType(selfTy, qs);
 820
 821       // In addition, 'self' is const unless this is an init method.
 822       if (getMethodFamily() != OMF_init && !selfIsConsumed) {
 823         selfTy = selfTy.withConst();
 824         selfIsPseudoStrong = true;
 825       }
 826     }
 827     else {
 828       assert(isClassMethod());
 829       // 'self' is always const in class methods.
 830       selfTy = selfTy.withConst();
 831       selfIsPseudoStrong = true;
 832     }
 833   }
 834
 835   ImplicitParamDecl *self
 836     = ImplicitParamDecl::Create(Context, this, SourceLocation(),
 837                                 &Context.Idents.get("self"), selfTy);
 838   setSelfDecl(self);
 839
 840   if (selfIsConsumed)
 841     self->addAttr(new (Context) NSConsumedAttr(SourceLocation(), Context));
 842
 843   if (selfIsPseudoStrong)
 844     self->setARCPseudoStrong(true);
 845
 846   setCmdDecl(ImplicitParamDecl::Create(Context, this, SourceLocation(),
 847                                        &Context.Idents.get("_cmd"),
 848                                        Context.getObjCSelType()));
 849 }
 850
 851 ObjCInterfaceDecl *ObjCMethodDecl::getClassInterface() {
 852   if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(getDeclContext()))
 853     return ID;
 854   if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(getDeclContext()))
 855     return CD->getClassInterface();
 856   if (ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(getDeclContext()))
 857     return IMD->getClassInterface();
 858
 859   assert(!isa<ObjCProtocolDecl>(getDeclContext()) && "It's a protocol method");
 860   llvm_unreachable("unknown method context");
 861 }
 862
 863 static void CollectOverriddenMethodsRecurse(const ObjCContainerDecl *Container,
 864                                             const ObjCMethodDecl *Method,
 865                                SmallVectorImpl<const ObjCMethodDecl *> &Methods,
 866                                             bool MovedToSuper) {
 867   if (!Container)
 868     return;
 869
 870   // In categories look for overriden methods from protocols. A method from
 871   // category is not "overriden" since it is considered as the "same" method
 872   // (same USR) as the one from the interface.
 873   if (const ObjCCategoryDecl *
 874         Category = dyn_cast<ObjCCategoryDecl>(Container)) {
 875     // Check whether we have a matching method at this category but only if we
 876     // are at the super class level.
 877     if (MovedToSuper)
 878       if (ObjCMethodDecl *
 879             Overridden = Container->getMethod(Method->getSelector(),
 880                                               Method->isInstanceMethod(),
 881                                               /*AllowHidden=*/true))
 882         if (Method != Overridden) {
 883           // We found an override at this category; there is no need to look
 884           // into its protocols.
 885           Methods.push_back(Overridden);
 886           return;
 887         }
 888
 889     for (ObjCCategoryDecl::protocol_iterator P = Category->protocol_begin(),
 890                                           PEnd = Category->protocol_end();
 891          P != PEnd; ++P)
 892       CollectOverriddenMethodsRecurse(*P, Method, Methods, MovedToSuper);
 893     return;
 894   }
 895
 896   // Check whether we have a matching method at this level.
 897   if (const ObjCMethodDecl *
 898         Overridden = Container->getMethod(Method->getSelector(),
 899                                           Method->isInstanceMethod(),
 900                                           /*AllowHidden=*/true))
 901     if (Method != Overridden) {
 902       // We found an override at this level; there is no need to look
 903       // into other protocols or categories.
 904       Methods.push_back(Overridden);
 905       return;
 906     }
 907
 908   if (const ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)){
 909     for (ObjCProtocolDecl::protocol_iterator P = Protocol->protocol_begin(),
 910                                           PEnd = Protocol->protocol_end();
 911          P != PEnd; ++P)
 912       CollectOverriddenMethodsRecurse(*P, Method, Methods, MovedToSuper);
 913   }
 914
 915   if (const ObjCInterfaceDecl *
 916         Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
 917     for (ObjCInterfaceDecl::protocol_iterator P = Interface->protocol_begin(),
 918                                            PEnd = Interface->protocol_end();
 919          P != PEnd; ++P)
 920       CollectOverriddenMethodsRecurse(*P, Method, Methods, MovedToSuper);
 921
 922     for (ObjCInterfaceDecl::known_categories_iterator
 923            Cat = Interface->known_categories_begin(),
 924            CatEnd = Interface->known_categories_end();
 925          Cat != CatEnd; ++Cat) {
 926       CollectOverriddenMethodsRecurse(*Cat, Method, Methods,
 927                                       MovedToSuper);
 928     }
 929
 930     if (const ObjCInterfaceDecl *Super = Interface->getSuperClass())
 931       return CollectOverriddenMethodsRecurse(Super, Method, Methods,
 932                                              /*MovedToSuper=*/true);
 933   }
 934 }
 935
 936 static inline void CollectOverriddenMethods(const ObjCContainerDecl *Container,
 937                                             const ObjCMethodDecl *Method,
 938                              SmallVectorImpl<const ObjCMethodDecl *> &Methods) {
 939   CollectOverriddenMethodsRecurse(Container, Method, Methods,
 940                                   /*MovedToSuper=*/false);
 941 }
 942
 943 static void collectOverriddenMethodsSlow(const ObjCMethodDecl *Method,
 944                           SmallVectorImpl<const ObjCMethodDecl *> &overridden) {
 945   assert(Method->isOverriding());
 946
 947   if (const ObjCProtocolDecl *
 948         ProtD = dyn_cast<ObjCProtocolDecl>(Method->getDeclContext())) {
 949     CollectOverriddenMethods(ProtD, Method, overridden);
 950
 951   } else if (const ObjCImplDecl *
 952                IMD = dyn_cast<ObjCImplDecl>(Method->getDeclContext())) {
 953     const ObjCInterfaceDecl *ID = IMD->getClassInterface();
 954     if (!ID)
 955       return;
 956     // Start searching for overridden methods using the method from the
 957     // interface as starting point.
 958     if (const ObjCMethodDecl *IFaceMeth = ID->getMethod(Method->getSelector(),
 959                                                     Method->isInstanceMethod(),
 960                                                     /*AllowHidden=*/true))
 961       Method = IFaceMeth;
 962     CollectOverriddenMethods(ID, Method, overridden);
 963
 964   } else if (const ObjCCategoryDecl *
 965                CatD = dyn_cast<ObjCCategoryDecl>(Method->getDeclContext())) {
 966     const ObjCInterfaceDecl *ID = CatD->getClassInterface();
 967     if (!ID)
 968       return;
 969     // Start searching for overridden methods using the method from the
 970     // interface as starting point.
 971     if (const ObjCMethodDecl *IFaceMeth = ID->getMethod(Method->getSelector(),
 972                                                      Method->isInstanceMethod(),
 973                                                      /*AllowHidden=*/true))
 974       Method = IFaceMeth;
 975     CollectOverriddenMethods(ID, Method, overridden);
 976
 977   } else {
 978     CollectOverriddenMethods(
 979                   dyn_cast_or_null<ObjCContainerDecl>(Method->getDeclContext()),
 980                   Method, overridden);
 981   }
 982 }
 983
 984 void ObjCMethodDecl::getOverriddenMethods(
 985                     SmallVectorImpl<const ObjCMethodDecl *> &Overridden) const {
 986   const ObjCMethodDecl *Method = this;
 987
 988   if (Method->isRedeclaration()) {
 989     Method = cast<ObjCContainerDecl>(Method->getDeclContext())->
 990                    getMethod(Method->getSelector(), Method->isInstanceMethod());
 991   }
 992
 993   if (Method->isOverriding()) {
 994     collectOverriddenMethodsSlow(Method, Overridden);
 995     assert(!Overridden.empty() &&
 996            "ObjCMethodDecl's overriding bit is not as expected");
 997   }
 998 }
 999
1000 const ObjCPropertyDecl *
1001 ObjCMethodDecl::findPropertyDecl(bool CheckOverrides) const {
1002   Selector Sel = getSelector();
1003   unsigned NumArgs = Sel.getNumArgs();
1004   if (NumArgs > 1)
1005     return 0;
1006
1007   if (!isInstanceMethod() || getMethodFamily() != OMF_None)
1008     return 0;
1009
1010   if (isPropertyAccessor()) {
1011     const ObjCContainerDecl *Container = cast<ObjCContainerDecl>(getParent());
1012     // If container is class extension, find its primary class.
1013     if (const ObjCCategoryDecl *CatDecl = dyn_cast<ObjCCategoryDecl>(Container))
1014       if (CatDecl->IsClassExtension())
1015         Container = CatDecl->getClassInterface();
1016
1017     bool IsGetter = (NumArgs == 0);
1018
1019     for (ObjCContainerDecl::prop_iterator I = Container->prop_begin(),
1020                                           E = Container->prop_end();
1021          I != E; ++I) {
1022       Selector NextSel = IsGetter ? (*I)->getGetterName()
1023                                   : (*I)->getSetterName();
1024       if (NextSel == Sel)
1025         return *I;
1026     }
1027
1028     llvm_unreachable("Marked as a property accessor but no property found!");
1029   }
1030
1031   if (!CheckOverrides)
1032     return 0;
1033
1034   typedef SmallVector<const ObjCMethodDecl *, 8> OverridesTy;
1035   OverridesTy Overrides;
1036   getOverriddenMethods(Overrides);
1037   for (OverridesTy::const_iterator I = Overrides.begin(), E = Overrides.end();
1038        I != E; ++I) {
1039     if (const ObjCPropertyDecl *Prop = (*I)->findPropertyDecl(false))
1040       return Prop;
1041   }
1042
1043   return 0;
1044
1045 }
1046
1047 //===----------------------------------------------------------------------===//
1048 // ObjCInterfaceDecl
1049 //===----------------------------------------------------------------------===//
1050
1051 ObjCInterfaceDecl *ObjCInterfaceDecl::Create(const ASTContext &C,
1052                                              DeclContext *DC,
1053                                              SourceLocation atLoc,
1054                                              IdentifierInfo *Id,
1055                                              ObjCInterfaceDecl *PrevDecl,
1056                                              SourceLocation ClassLoc,
1057                                              bool isInternal){
1058   ObjCInterfaceDecl *Result = new (C) ObjCInterfaceDecl(DC, atLoc, Id, ClassLoc,
1059                                                         PrevDecl, isInternal);
1060   Result->Data.setInt(!C.getLangOpts().Modules);
1061   C.getObjCInterfaceType(Result, PrevDecl);
1062   return Result;
1063 }
1064
1065 ObjCInterfaceDecl *ObjCInterfaceDecl::CreateDeserialized(ASTContext &C,
1066                                                          unsigned ID) {
1067   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCInterfaceDecl));
1068   ObjCInterfaceDecl *Result = new (Mem) ObjCInterfaceDecl(0, SourceLocation(),
1069                                                           0, SourceLocation(),
1070                                                           0, false);
1071   Result->Data.setInt(!C.getLangOpts().Modules);
1072   return Result;
1073 }
1074
1075 ObjCInterfaceDecl::
1076 ObjCInterfaceDecl(DeclContext *DC, SourceLocation atLoc, IdentifierInfo *Id,
1077                   SourceLocation CLoc, ObjCInterfaceDecl *PrevDecl,
1078                   bool isInternal)
1079   : ObjCContainerDecl(ObjCInterface, DC, Id, CLoc, atLoc),
1080     TypeForDecl(0), Data()
1081 {
1082   setPreviousDecl(PrevDecl);
1083
1084   // Copy the 'data' pointer over.
1085   if (PrevDecl)
1086     Data = PrevDecl->Data;
1087
1088   setImplicit(isInternal);
1089 }
1090
1091 void ObjCInterfaceDecl::LoadExternalDefinition() const {
1092   assert(data().ExternallyCompleted && "Class is not externally completed");
1093   data().ExternallyCompleted = false;
1094   getASTContext().getExternalSource()->CompleteType(
1095                                         const_cast<ObjCInterfaceDecl *>(this));
1096 }
1097
1098 void ObjCInterfaceDecl::setExternallyCompleted() {
1099   assert(getASTContext().getExternalSource() &&
1100          "Class can't be externally completed without an external source");
1101   assert(hasDefinition() &&
1102          "Forward declarations can't be externally completed");
1103   data().ExternallyCompleted = true;
1104 }
1105
1106 ObjCImplementationDecl *ObjCInterfaceDecl::getImplementation() const {
1107   if (const ObjCInterfaceDecl *Def = getDefinition()) {
1108     if (data().ExternallyCompleted)
1109       LoadExternalDefinition();
1110
1111     return getASTContext().getObjCImplementation(
1112              const_cast<ObjCInterfaceDecl*>(Def));
1113   }
1114
1115   // FIXME: Should make sure no callers ever do this.
1116   return 0;
1117 }
1118
1119 void ObjCInterfaceDecl::setImplementation(ObjCImplementationDecl *ImplD) {
1120   getASTContext().setObjCImplementation(getDefinition(), ImplD);
1121 }
1122
1123 namespace {
1124   struct SynthesizeIvarChunk {
1125     uint64_t Size;
1126     ObjCIvarDecl *Ivar;
1127     SynthesizeIvarChunk(uint64_t size, ObjCIvarDecl *ivar)
1128       : Size(size), Ivar(ivar) {}
1129   };
1130
1131   bool operator<(const SynthesizeIvarChunk & LHS,
1132                  const SynthesizeIvarChunk &RHS) {
1133       return LHS.Size < RHS.Size;
1134   }
1135 }
1136
1137 /// all_declared_ivar_begin - return first ivar declared in this class,
1138 /// its extensions and its implementation. Lazily build the list on first
1139 /// access.
1140 ///
1141 /// Caveat: The list returned by this method reflects the current
1142 /// state of the parser. The cache will be updated for every ivar
1143 /// added by an extension or the implementation when they are
1144 /// encountered.
1145 /// See also ObjCIvarDecl::Create().
1146 ObjCIvarDecl *ObjCInterfaceDecl::all_declared_ivar_begin() {
1147   // FIXME: Should make sure no callers ever do this.
1148   if (!hasDefinition())
1149     return 0;
1150
1151   ObjCIvarDecl *curIvar = 0;
1152   if (!data().IvarList) {
1153     if (!ivar_empty()) {
1154       ObjCInterfaceDecl::ivar_iterator I = ivar_begin(), E = ivar_end();
1155       data().IvarList = *I; ++I;
1156       for (curIvar = data().IvarList; I != E; curIvar = *I, ++I)
1157         curIvar->setNextIvar(*I);
1158     }
1159
1160     for (ObjCInterfaceDecl::known_extensions_iterator
1161            Ext = known_extensions_begin(),
1162            ExtEnd = known_extensions_end();
1163          Ext != ExtEnd; ++Ext) {
1164       if (!Ext->ivar_empty()) {
1165         ObjCCategoryDecl::ivar_iterator
1166           I = Ext->ivar_begin(),
1167           E = Ext->ivar_end();
1168         if (!data().IvarList) {
1169           data().IvarList = *I; ++I;
1170           curIvar = data().IvarList;
1171         }
1172         for ( ;I != E; curIvar = *I, ++I)
1173           curIvar->setNextIvar(*I);
1174       }
1175     }
1176     data().IvarListMissingImplementation = true;
1177   }
1178
1179   // cached and complete!
1180   if (!data().IvarListMissingImplementation)
1181       return data().IvarList;
1182
1183   if (ObjCImplementationDecl *ImplDecl = getImplementation()) {
1184     data().IvarListMissingImplementation = false;
1185     if (!ImplDecl->ivar_empty()) {
1186       SmallVector<SynthesizeIvarChunk, 16> layout;
1187       for (ObjCImplementationDecl::ivar_iterator I = ImplDecl->ivar_begin(),
1188            E = ImplDecl->ivar_end(); I != E; ++I) {
1189         ObjCIvarDecl *IV = *I;
1190         if (IV->getSynthesize() && !IV->isInvalidDecl()) {
1191           layout.push_back(SynthesizeIvarChunk(
1192                              IV->getASTContext().getTypeSize(IV->getType()), IV));
1193           continue;
1194         }
1195         if (!data().IvarList)
1196           data().IvarList = *I;
1197         else
1198           curIvar->setNextIvar(*I);
1199         curIvar = *I;
1200       }
1201
1202       if (!layout.empty()) {
1203         // Order synthesized ivars by their size.
1204         std::stable_sort(layout.begin(), layout.end());
1205         unsigned Ix = 0, EIx = layout.size();
1206         if (!data().IvarList) {
1207           data().IvarList = layout[0].Ivar; Ix++;
1208           curIvar = data().IvarList;
1209         }
1210         for ( ; Ix != EIx; curIvar = layout[Ix].Ivar, Ix++)
1211           curIvar->setNextIvar(layout[Ix].Ivar);
1212       }
1213     }
1214   }
1215   return data().IvarList;
1216 }
1217
1218 /// FindCategoryDeclaration - Finds category declaration in the list of
1219 /// categories for this class and returns it. Name of the category is passed
1220 /// in 'CategoryId'. If category not found, return 0;
1221 ///
1222 ObjCCategoryDecl *
1223 ObjCInterfaceDecl::FindCategoryDeclaration(IdentifierInfo *CategoryId) const {
1224   // FIXME: Should make sure no callers ever do this.
1225   if (!hasDefinition())
1226     return 0;
1227
1228   if (data().ExternallyCompleted)
1229     LoadExternalDefinition();
1230
1231   for (visible_categories_iterator Cat = visible_categories_begin(),
1232                                    CatEnd = visible_categories_end();
1233        Cat != CatEnd;
1234        ++Cat) {
1235     if (Cat->getIdentifier() == CategoryId)
1236       return *Cat;
1237   }
1238
1239   return 0;
1240 }
1241
1242 ObjCMethodDecl *
1243 ObjCInterfaceDecl::getCategoryInstanceMethod(Selector Sel) const {
1244   for (visible_categories_iterator Cat = visible_categories_begin(),
1245                                    CatEnd = visible_categories_end();
1246        Cat != CatEnd;
1247        ++Cat) {
1248     if (ObjCCategoryImplDecl *Impl = Cat->getImplementation())
1249       if (ObjCMethodDecl *MD = Impl->getInstanceMethod(Sel))
1250         return MD;
1251   }
1252
1253   return 0;
1254 }
1255
1256 ObjCMethodDecl *ObjCInterfaceDecl::getCategoryClassMethod(Selector Sel) const {
1257   for (visible_categories_iterator Cat = visible_categories_begin(),
1258                                    CatEnd = visible_categories_end();
1259        Cat != CatEnd;
1260        ++Cat) {
1261     if (ObjCCategoryImplDecl *Impl = Cat->getImplementation())
1262       if (ObjCMethodDecl *MD = Impl->getClassMethod(Sel))
1263         return MD;
1264   }
1265
1266   return 0;
1267 }
1268
1269 /// ClassImplementsProtocol - Checks that 'lProto' protocol
1270 /// has been implemented in IDecl class, its super class or categories (if
1271 /// lookupCategory is true).
1272 bool ObjCInterfaceDecl::ClassImplementsProtocol(ObjCProtocolDecl *lProto,
1273                                     bool lookupCategory,
1274                                     bool RHSIsQualifiedID) {
1275   if (!hasDefinition())
1276     return false;
1277
1278   ObjCInterfaceDecl *IDecl = this;
1279   // 1st, look up the class.
1280   for (ObjCInterfaceDecl::protocol_iterator
1281         PI = IDecl->protocol_begin(), E = IDecl->protocol_end(); PI != E; ++PI){
1282     if (getASTContext().ProtocolCompatibleWithProtocol(lProto, *PI))
1283       return true;
1284     // This is dubious and is added to be compatible with gcc.  In gcc, it is
1285     // also allowed assigning a protocol-qualified 'id' type to a LHS object
1286     // when protocol in qualified LHS is in list of protocols in the rhs 'id'
1287     // object. This IMO, should be a bug.
1288     // FIXME: Treat this as an extension, and flag this as an error when GCC
1289     // extensions are not enabled.
1290     if (RHSIsQualifiedID &&
1291         getASTContext().ProtocolCompatibleWithProtocol(*PI, lProto))
1292       return true;
1293   }
1294
1295   // 2nd, look up the category.
1296   if (lookupCategory)
1297     for (visible_categories_iterator Cat = visible_categories_begin(),
1298                                      CatEnd = visible_categories_end();
1299          Cat != CatEnd;
1300          ++Cat) {
1301       for (ObjCCategoryDecl::protocol_iterator PI = Cat->protocol_begin(),
1302                                                E = Cat->protocol_end();
1303            PI != E; ++PI)
1304         if (getASTContext().ProtocolCompatibleWithProtocol(lProto, *PI))
1305           return true;
1306     }
1307
1308   // 3rd, look up the super class(s)
1309   if (IDecl->getSuperClass())
1310     return
1311   IDecl->getSuperClass()->ClassImplementsProtocol(lProto, lookupCategory,
1312                                                   RHSIsQualifiedID);
1313
1314   return false;
1315 }
1316
1317 //===----------------------------------------------------------------------===//
1318 // ObjCIvarDecl
1319 //===----------------------------------------------------------------------===//
1320
1321 void ObjCIvarDecl::anchor() { }
1322
1323 ObjCIvarDecl *ObjCIvarDecl::Create(ASTContext &C, ObjCContainerDecl *DC,
1324                                    SourceLocation StartLoc,
1325                                    SourceLocation IdLoc, IdentifierInfo *Id,
1326                                    QualType T, TypeSourceInfo *TInfo,
1327                                    AccessControl ac, Expr *BW,
1328                                    bool synthesized,
1329                                    bool backingIvarReferencedInAccessor) {
1330   if (DC) {
1331     // Ivar's can only appear in interfaces, implementations (via synthesized
1332     // properties), and class extensions (via direct declaration, or synthesized
1333     // properties).
1334     //
1335     // FIXME: This should really be asserting this:
1336     //   (isa<ObjCCategoryDecl>(DC) &&
1337     //    cast<ObjCCategoryDecl>(DC)->IsClassExtension()))
1338     // but unfortunately we sometimes place ivars into non-class extension
1339     // categories on error. This breaks an AST invariant, and should not be
1340     // fixed.
1341     assert((isa<ObjCInterfaceDecl>(DC) || isa<ObjCImplementationDecl>(DC) ||
1342             isa<ObjCCategoryDecl>(DC)) &&
1343            "Invalid ivar decl context!");
1344     // Once a new ivar is created in any of class/class-extension/implementation
1345     // decl contexts, the previously built IvarList must be rebuilt.
1346     ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(DC);
1347     if (!ID) {
1348       if (ObjCImplementationDecl *IM = dyn_cast<ObjCImplementationDecl>(DC))
1349         ID = IM->getClassInterface();
1350       else
1351         ID = cast<ObjCCategoryDecl>(DC)->getClassInterface();
1352     }
1353     ID->setIvarList(0);
1354   }
1355
1356   return new (C) ObjCIvarDecl(DC, StartLoc, IdLoc, Id, T, TInfo,
1357                               ac, BW, synthesized, backingIvarReferencedInAccessor);
1358 }
1359
1360 ObjCIvarDecl *ObjCIvarDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1361   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCIvarDecl));
1362   return new (Mem) ObjCIvarDecl(0, SourceLocation(), SourceLocation(), 0,
1363                                 QualType(), 0, ObjCIvarDecl::None, 0, false, false);
1364 }
1365
1366 const ObjCInterfaceDecl *ObjCIvarDecl::getContainingInterface() const {
1367   const ObjCContainerDecl *DC = cast<ObjCContainerDecl>(getDeclContext());
1368
1369   switch (DC->getKind()) {
1370   default:
1371   case ObjCCategoryImpl:
1372   case ObjCProtocol:
1373     llvm_unreachable("invalid ivar container!");
1374
1375     // Ivars can only appear in class extension categories.
1376   case ObjCCategory: {
1377     const ObjCCategoryDecl *CD = cast<ObjCCategoryDecl>(DC);
1378     assert(CD->IsClassExtension() && "invalid container for ivar!");
1379     return CD->getClassInterface();
1380   }
1381
1382   case ObjCImplementation:
1383     return cast<ObjCImplementationDecl>(DC)->getClassInterface();
1384
1385   case ObjCInterface:
1386     return cast<ObjCInterfaceDecl>(DC);
1387   }
1388 }
1389
1390 //===----------------------------------------------------------------------===//
1391 // ObjCAtDefsFieldDecl
1392 //===----------------------------------------------------------------------===//
1393
1394 void ObjCAtDefsFieldDecl::anchor() { }
1395
1396 ObjCAtDefsFieldDecl
1397 *ObjCAtDefsFieldDecl::Create(ASTContext &C, DeclContext *DC,
1398                              SourceLocation StartLoc,  SourceLocation IdLoc,
1399                              IdentifierInfo *Id, QualType T, Expr *BW) {
1400   return new (C) ObjCAtDefsFieldDecl(DC, StartLoc, IdLoc, Id, T, BW);
1401 }
1402
1403 ObjCAtDefsFieldDecl *ObjCAtDefsFieldDecl::CreateDeserialized(ASTContext &C,
1404                                                              unsigned ID) {
1405   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCAtDefsFieldDecl));
1406   return new (Mem) ObjCAtDefsFieldDecl(0, SourceLocation(), SourceLocation(),
1407                                        0, QualType(), 0);
1408 }
1409
1410 //===----------------------------------------------------------------------===//
1411 // ObjCProtocolDecl
1412 //===----------------------------------------------------------------------===//
1413
1414 void ObjCProtocolDecl::anchor() { }
1415
1416 ObjCProtocolDecl::ObjCProtocolDecl(DeclContext *DC, IdentifierInfo *Id,
1417                                    SourceLocation nameLoc,
1418                                    SourceLocation atStartLoc,
1419                                    ObjCProtocolDecl *PrevDecl)
1420   : ObjCContainerDecl(ObjCProtocol, DC, Id, nameLoc, atStartLoc), Data()
1421 {
1422   setPreviousDecl(PrevDecl);
1423   if (PrevDecl)
1424     Data = PrevDecl->Data;
1425 }
1426
1427 ObjCProtocolDecl *ObjCProtocolDecl::Create(ASTContext &C, DeclContext *DC,
1428                                            IdentifierInfo *Id,
1429                                            SourceLocation nameLoc,
1430                                            SourceLocation atStartLoc,
1431                                            ObjCProtocolDecl *PrevDecl) {
1432   ObjCProtocolDecl *Result
1433     = new (C) ObjCProtocolDecl(DC, Id, nameLoc, atStartLoc, PrevDecl);
1434   Result->Data.setInt(!C.getLangOpts().Modules);
1435   return Result;
1436 }
1437
1438 ObjCProtocolDecl *ObjCProtocolDecl::CreateDeserialized(ASTContext &C,
1439                                                        unsigned ID) {
1440   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCProtocolDecl));
1441   ObjCProtocolDecl *Result = new (Mem) ObjCProtocolDecl(0, 0, SourceLocation(),
1442                                                         SourceLocation(), 0);
1443   Result->Data.setInt(!C.getLangOpts().Modules);
1444   return Result;
1445 }
1446
1447 ObjCProtocolDecl *ObjCProtocolDecl::lookupProtocolNamed(IdentifierInfo *Name) {
1448   ObjCProtocolDecl *PDecl = this;
1449
1450   if (Name == getIdentifier())
1451     return PDecl;
1452
1453   for (protocol_iterator I = protocol_begin(), E = protocol_end(); I != E; ++I)
1454     if ((PDecl = (*I)->lookupProtocolNamed(Name)))
1455       return PDecl;
1456
1457   return NULL;
1458 }
1459
1460 // lookupMethod - Lookup a instance/class method in the protocol and protocols
1461 // it inherited.
1462 ObjCMethodDecl *ObjCProtocolDecl::lookupMethod(Selector Sel,
1463                                                bool isInstance) const {
1464   ObjCMethodDecl *MethodDecl = NULL;
1465
1466   // If there is no definition or the definition is hidden, we don't find
1467   // anything.
1468   const ObjCProtocolDecl *Def = getDefinition();
1469   if (!Def || Def->isHidden())
1470     return NULL;
1471
1472   if ((MethodDecl = getMethod(Sel, isInstance)))
1473     return MethodDecl;
1474
1475   for (protocol_iterator I = protocol_begin(), E = protocol_end(); I != E; ++I)
1476     if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance)))
1477       return MethodDecl;
1478   return NULL;
1479 }
1480
1481 void ObjCProtocolDecl::allocateDefinitionData() {
1482   assert(!Data.getPointer() && "Protocol already has a definition!");
1483   Data.setPointer(new (getASTContext()) DefinitionData);
1484   Data.getPointer()->Definition = this;
1485 }
1486
1487 void ObjCProtocolDecl::startDefinition() {
1488   allocateDefinitionData();
1489
1490   // Update all of the declarations with a pointer to the definition.
1491   for (redecl_iterator RD = redecls_begin(), RDEnd = redecls_end();
1492        RD != RDEnd; ++RD)
1493     RD->Data = this->Data;
1494 }
1495
1496 void ObjCProtocolDecl::collectPropertiesToImplement(PropertyMap &PM,
1497                                                     PropertyDeclOrder &PO) const {
1498
1499   if (const ObjCProtocolDecl *PDecl = getDefinition()) {
1500     for (ObjCProtocolDecl::prop_iterator P = PDecl->prop_begin(),
1501          E = PDecl->prop_end(); P != E; ++P) {
1502       ObjCPropertyDecl *Prop = *P;
1503       // Insert into PM if not there already.
1504       PM.insert(std::make_pair(Prop->getIdentifier(), Prop));
1505       PO.push_back(Prop);
1506     }
1507     // Scan through protocol's protocols.
1508     for (ObjCProtocolDecl::protocol_iterator PI = PDecl->protocol_begin(),
1509          E = PDecl->protocol_end(); PI != E; ++PI)
1510       (*PI)->collectPropertiesToImplement(PM, PO);
1511   }
1512 }
1513
1514
1515 void ObjCProtocolDecl::collectInheritedProtocolProperties(
1516                                                 const ObjCPropertyDecl *Property,
1517                                                 ProtocolPropertyMap &PM) const {
1518   if (const ObjCProtocolDecl *PDecl = getDefinition()) {
1519     bool MatchFound = false;
1520     for (ObjCProtocolDecl::prop_iterator P = PDecl->prop_begin(),
1521          E = PDecl->prop_end(); P != E; ++P) {
1522       ObjCPropertyDecl *Prop = *P;
1523       if (Prop == Property)
1524         continue;
1525       if (Prop->getIdentifier() == Property->getIdentifier()) {
1526         PM[PDecl] = Prop;
1527         MatchFound = true;
1528         break;
1529       }
1530     }
1531     // Scan through protocol's protocols which did not have a matching property.
1532     if (!MatchFound)
1533       for (ObjCProtocolDecl::protocol_iterator PI = PDecl->protocol_begin(),
1534            E = PDecl->protocol_end(); PI != E; ++PI)
1535         (*PI)->collectInheritedProtocolProperties(Property, PM);
1536   }
1537 }
1538
1539 //===----------------------------------------------------------------------===//
1540 // ObjCCategoryDecl
1541 //===----------------------------------------------------------------------===//
1542
1543 void ObjCCategoryDecl::anchor() { }
1544
1545 ObjCCategoryDecl *ObjCCategoryDecl::Create(ASTContext &C, DeclContext *DC,
1546                                            SourceLocation AtLoc,
1547                                            SourceLocation ClassNameLoc,
1548                                            SourceLocation CategoryNameLoc,
1549                                            IdentifierInfo *Id,
1550                                            ObjCInterfaceDecl *IDecl,
1551                                            SourceLocation IvarLBraceLoc,
1552                                            SourceLocation IvarRBraceLoc) {
1553   ObjCCategoryDecl *CatDecl = new (C) ObjCCategoryDecl(DC, AtLoc, ClassNameLoc,
1554                                                        CategoryNameLoc, Id,
1555                                                        IDecl,
1556                                                        IvarLBraceLoc, IvarRBraceLoc);
1557   if (IDecl) {
1558     // Link this category into its class's category list.
1559     CatDecl->NextClassCategory = IDecl->getCategoryListRaw();
1560     if (IDecl->hasDefinition()) {
1561       IDecl->setCategoryListRaw(CatDecl);
1562       if (ASTMutationListener *L = C.getASTMutationListener())
1563         L->AddedObjCCategoryToInterface(CatDecl, IDecl);
1564     }
1565   }
1566
1567   return CatDecl;
1568 }
1569
1570 ObjCCategoryDecl *ObjCCategoryDecl::CreateDeserialized(ASTContext &C,
1571                                                        unsigned ID) {
1572   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCCategoryDecl));
1573   return new (Mem) ObjCCategoryDecl(0, SourceLocation(), SourceLocation(),
1574                                     SourceLocation(), 0, 0);
1575 }
1576
1577 ObjCCategoryImplDecl *ObjCCategoryDecl::getImplementation() const {
1578   return getASTContext().getObjCImplementation(
1579                                            const_cast<ObjCCategoryDecl*>(this));
1580 }
1581
1582 void ObjCCategoryDecl::setImplementation(ObjCCategoryImplDecl *ImplD) {
1583   getASTContext().setObjCImplementation(this, ImplD);
1584 }
1585
1586
1587 //===----------------------------------------------------------------------===//
1588 // ObjCCategoryImplDecl
1589 //===----------------------------------------------------------------------===//
1590
1591 void ObjCCategoryImplDecl::anchor() { }
1592
1593 ObjCCategoryImplDecl *
1594 ObjCCategoryImplDecl::Create(ASTContext &C, DeclContext *DC,
1595                              IdentifierInfo *Id,
1596                              ObjCInterfaceDecl *ClassInterface,
1597                              SourceLocation nameLoc,
1598                              SourceLocation atStartLoc,
1599                              SourceLocation CategoryNameLoc) {
1600   if (ClassInterface && ClassInterface->hasDefinition())
1601     ClassInterface = ClassInterface->getDefinition();
1602   return new (C) ObjCCategoryImplDecl(DC, Id, ClassInterface,
1603                                       nameLoc, atStartLoc, CategoryNameLoc);
1604 }
1605
1606 ObjCCategoryImplDecl *ObjCCategoryImplDecl::CreateDeserialized(ASTContext &C,
1607                                                                unsigned ID) {
1608   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCCategoryImplDecl));
1609   return new (Mem) ObjCCategoryImplDecl(0, 0, 0, SourceLocation(),
1610                                         SourceLocation(), SourceLocation());
1611 }
1612
1613 ObjCCategoryDecl *ObjCCategoryImplDecl::getCategoryDecl() const {
1614   // The class interface might be NULL if we are working with invalid code.
1615   if (const ObjCInterfaceDecl *ID = getClassInterface())
1616     return ID->FindCategoryDeclaration(getIdentifier());
1617   return 0;
1618 }
1619
1620
1621 void ObjCImplDecl::anchor() { }
1622
1623 void ObjCImplDecl::addPropertyImplementation(ObjCPropertyImplDecl *property) {
1624   // FIXME: The context should be correct before we get here.
1625   property->setLexicalDeclContext(this);
1626   addDecl(property);
1627 }
1628
1629 void ObjCImplDecl::setClassInterface(ObjCInterfaceDecl *IFace) {
1630   ASTContext &Ctx = getASTContext();
1631
1632   if (ObjCImplementationDecl *ImplD
1633         = dyn_cast_or_null<ObjCImplementationDecl>(this)) {
1634     if (IFace)
1635       Ctx.setObjCImplementation(IFace, ImplD);
1636
1637   } else if (ObjCCategoryImplDecl *ImplD =
1638              dyn_cast_or_null<ObjCCategoryImplDecl>(this)) {
1639     if (ObjCCategoryDecl *CD = IFace->FindCategoryDeclaration(getIdentifier()))
1640       Ctx.setObjCImplementation(CD, ImplD);
1641   }
1642
1643   ClassInterface = IFace;
1644 }
1645
1646 /// FindPropertyImplIvarDecl - This method lookup the ivar in the list of
1647 /// properties implemented in this \@implementation block and returns
1648 /// the implemented property that uses it.
1649 ///
1650 ObjCPropertyImplDecl *ObjCImplDecl::
1651 FindPropertyImplIvarDecl(IdentifierInfo *ivarId) const {
1652   for (propimpl_iterator i = propimpl_begin(), e = propimpl_end(); i != e; ++i){
1653     ObjCPropertyImplDecl *PID = *i;
1654     if (PID->getPropertyIvarDecl() &&
1655         PID->getPropertyIvarDecl()->getIdentifier() == ivarId)
1656       return PID;
1657   }
1658   return 0;
1659 }
1660
1661 /// FindPropertyImplDecl - This method looks up a previous ObjCPropertyImplDecl
1662 /// added to the list of those properties \@synthesized/\@dynamic in this
1663 /// category \@implementation block.
1664 ///
1665 ObjCPropertyImplDecl *ObjCImplDecl::
1666 FindPropertyImplDecl(IdentifierInfo *Id) const {
1667   for (propimpl_iterator i = propimpl_begin(), e = propimpl_end(); i != e; ++i){
1668     ObjCPropertyImplDecl *PID = *i;
1669     if (PID->getPropertyDecl()->getIdentifier() == Id)
1670       return PID;
1671   }
1672   return 0;
1673 }
1674
1675 raw_ostream &clang::operator<<(raw_ostream &OS,
1676                                const ObjCCategoryImplDecl &CID) {
1677   OS << CID.getName();
1678   return OS;
1679 }
1680
1681 //===----------------------------------------------------------------------===//
1682 // ObjCImplementationDecl
1683 //===----------------------------------------------------------------------===//
1684
1685 void ObjCImplementationDecl::anchor() { }
1686
1687 ObjCImplementationDecl *
1688 ObjCImplementationDecl::Create(ASTContext &C, DeclContext *DC,
1689                                ObjCInterfaceDecl *ClassInterface,
1690                                ObjCInterfaceDecl *SuperDecl,
1691                                SourceLocation nameLoc,
1692                                SourceLocation atStartLoc,
1693                                SourceLocation superLoc,
1694                                SourceLocation IvarLBraceLoc,
1695                                SourceLocation IvarRBraceLoc) {
1696   if (ClassInterface && ClassInterface->hasDefinition())
1697     ClassInterface = ClassInterface->getDefinition();
1698   return new (C) ObjCImplementationDecl(DC, ClassInterface, SuperDecl,
1699                                         nameLoc, atStartLoc, superLoc,
1700                                         IvarLBraceLoc, IvarRBraceLoc);
1701 }
1702
1703 ObjCImplementationDecl *
1704 ObjCImplementationDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1705   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCImplementationDecl));
1706   return new (Mem) ObjCImplementationDecl(0, 0, 0, SourceLocation(),
1707                                           SourceLocation());
1708 }
1709
1710 void ObjCImplementationDecl::setIvarInitializers(ASTContext &C,
1711                                              CXXCtorInitializer ** initializers,
1712                                                  unsigned numInitializers) {
1713   if (numInitializers > 0) {
1714     NumIvarInitializers = numInitializers;
1715     CXXCtorInitializer **ivarInitializers =
1716     new (C) CXXCtorInitializer*[NumIvarInitializers];
1717     memcpy(ivarInitializers, initializers,
1718            numInitializers * sizeof(CXXCtorInitializer*));
1719     IvarInitializers = ivarInitializers;
1720   }
1721 }
1722
1723 raw_ostream &clang::operator<<(raw_ostream &OS,
1724                                const ObjCImplementationDecl &ID) {
1725   OS << ID.getName();
1726   return OS;
1727 }
1728
1729 //===----------------------------------------------------------------------===//
1730 // ObjCCompatibleAliasDecl
1731 //===----------------------------------------------------------------------===//
1732
1733 void ObjCCompatibleAliasDecl::anchor() { }
1734
1735 ObjCCompatibleAliasDecl *
1736 ObjCCompatibleAliasDecl::Create(ASTContext &C, DeclContext *DC,
1737                                 SourceLocation L,
1738                                 IdentifierInfo *Id,
1739                                 ObjCInterfaceDecl* AliasedClass) {
1740   return new (C) ObjCCompatibleAliasDecl(DC, L, Id, AliasedClass);
1741 }
1742
1743 ObjCCompatibleAliasDecl *
1744 ObjCCompatibleAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1745   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCCompatibleAliasDecl));
1746   return new (Mem) ObjCCompatibleAliasDecl(0, SourceLocation(), 0, 0);
1747 }
1748
1749 //===----------------------------------------------------------------------===//
1750 // ObjCPropertyDecl
1751 //===----------------------------------------------------------------------===//
1752
1753 void ObjCPropertyDecl::anchor() { }
1754
1755 ObjCPropertyDecl *ObjCPropertyDecl::Create(ASTContext &C, DeclContext *DC,
1756                                            SourceLocation L,
1757                                            IdentifierInfo *Id,
1758                                            SourceLocation AtLoc,
1759                                            SourceLocation LParenLoc,
1760                                            TypeSourceInfo *T,
1761                                            PropertyControl propControl) {
1762   return new (C) ObjCPropertyDecl(DC, L, Id, AtLoc, LParenLoc, T);
1763 }
1764
1765 ObjCPropertyDecl *ObjCPropertyDecl::CreateDeserialized(ASTContext &C,
1766                                                        unsigned ID) {
1767   void * Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCPropertyDecl));
1768   return new (Mem) ObjCPropertyDecl(0, SourceLocation(), 0, SourceLocation(),
1769                                     SourceLocation(),
1770                                     0);
1771 }
1772
1773 //===----------------------------------------------------------------------===//
1774 // ObjCPropertyImplDecl
1775 //===----------------------------------------------------------------------===//
1776
1777 ObjCPropertyImplDecl *ObjCPropertyImplDecl::Create(ASTContext &C,
1778                                                    DeclContext *DC,
1779                                                    SourceLocation atLoc,
1780                                                    SourceLocation L,
1781                                                    ObjCPropertyDecl *property,
1782                                                    Kind PK,
1783                                                    ObjCIvarDecl *ivar,
1784                                                    SourceLocation ivarLoc) {
1785   return new (C) ObjCPropertyImplDecl(DC, atLoc, L, property, PK, ivar,
1786                                       ivarLoc);
1787 }
1788
1789 ObjCPropertyImplDecl *ObjCPropertyImplDecl::CreateDeserialized(ASTContext &C,
1790                                                                unsigned ID) {
1791   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCPropertyImplDecl));
1792   return new (Mem) ObjCPropertyImplDecl(0, SourceLocation(), SourceLocation(),
1793                                         0, Dynamic, 0, SourceLocation());
1794 }
1795
1796 SourceRange ObjCPropertyImplDecl::getSourceRange() const {
1797   SourceLocation EndLoc = getLocation();
1798   if (IvarLoc.isValid())
1799     EndLoc = IvarLoc;
1800
1801   return SourceRange(AtLoc, EndLoc);
1802 }