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