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