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