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