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