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