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