clang/lib/AST/DeclObjC.cpp

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