1 //===--- DeclObjC.cpp - ObjC Declaration AST Node Implementation ----------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the Objective-C related Decl classes.
12 //===----------------------------------------------------------------------===//
14 #include "clang/AST/DeclObjC.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/Stmt.h"
17 #include "llvm/ADT/STLExtras.h"
18 using namespace clang;
20 //===----------------------------------------------------------------------===//
22 //===----------------------------------------------------------------------===//
24 void ObjCListBase::set(void *const* InList, unsigned Elts, ASTContext &Ctx) {
26 if (Elts == 0) return; // Setting to an empty list is a noop.
29 List = new (Ctx) void*[Elts];
31 memcpy(List, InList, sizeof(void*)*Elts);
34 void ObjCProtocolList::set(ObjCProtocolDecl* const* InList, unsigned Elts,
35 const SourceLocation *Locs, ASTContext &Ctx) {
39 Locations = new (Ctx) SourceLocation[Elts];
40 memcpy(Locations, Locs, sizeof(SourceLocation) * Elts);
41 set(InList, Elts, Ctx);
44 //===----------------------------------------------------------------------===//
46 //===----------------------------------------------------------------------===//
48 /// getIvarDecl - This method looks up an ivar in this ContextDecl.
51 ObjCContainerDecl::getIvarDecl(IdentifierInfo *Id) const {
52 lookup_const_iterator Ivar, IvarEnd;
53 for (llvm::tie(Ivar, IvarEnd) = lookup(Id); Ivar != IvarEnd; ++Ivar) {
54 if (ObjCIvarDecl *ivar = dyn_cast<ObjCIvarDecl>(*Ivar))
60 // Get the local instance/class method declared in this interface.
62 ObjCContainerDecl::getMethod(Selector Sel, bool isInstance) const {
63 // Since instance & class methods can have the same name, the loop below
64 // ensures we get the correct method.
66 // @interface Whatever
67 // - (int) class_method;
68 // + (float) class_method;
71 lookup_const_iterator Meth, MethEnd;
72 for (llvm::tie(Meth, MethEnd) = lookup(Sel); Meth != MethEnd; ++Meth) {
73 ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(*Meth);
74 if (MD && MD->isInstanceMethod() == isInstance)
81 ObjCPropertyDecl::findPropertyDecl(const DeclContext *DC,
82 IdentifierInfo *propertyID) {
84 DeclContext::lookup_const_iterator I, E;
85 llvm::tie(I, E) = DC->lookup(propertyID);
87 if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(*I))
93 /// FindPropertyDeclaration - Finds declaration of the property given its name
94 /// in 'PropertyId' and returns it. It returns 0, if not found.
96 ObjCContainerDecl::FindPropertyDeclaration(IdentifierInfo *PropertyId) const {
98 if (ObjCPropertyDecl *PD =
99 ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(this), PropertyId))
105 case Decl::ObjCProtocol: {
106 const ObjCProtocolDecl *PID = cast<ObjCProtocolDecl>(this);
107 for (ObjCProtocolDecl::protocol_iterator I = PID->protocol_begin(),
108 E = PID->protocol_end(); I != E; ++I)
109 if (ObjCPropertyDecl *P = (*I)->FindPropertyDeclaration(PropertyId))
113 case Decl::ObjCInterface: {
114 const ObjCInterfaceDecl *OID = cast<ObjCInterfaceDecl>(this);
115 // Look through categories.
116 for (ObjCCategoryDecl *Cat = OID->getCategoryList();
117 Cat; Cat = Cat->getNextClassCategory())
118 if (!Cat->IsClassExtension())
119 if (ObjCPropertyDecl *P = Cat->FindPropertyDeclaration(PropertyId))
122 // Look through protocols.
123 for (ObjCInterfaceDecl::all_protocol_iterator
124 I = OID->all_referenced_protocol_begin(),
125 E = OID->all_referenced_protocol_end(); I != E; ++I)
126 if (ObjCPropertyDecl *P = (*I)->FindPropertyDeclaration(PropertyId))
129 // Finally, check the super class.
130 if (const ObjCInterfaceDecl *superClass = OID->getSuperClass())
131 return superClass->FindPropertyDeclaration(PropertyId);
134 case Decl::ObjCCategory: {
135 const ObjCCategoryDecl *OCD = cast<ObjCCategoryDecl>(this);
136 // Look through protocols.
137 if (!OCD->IsClassExtension())
138 for (ObjCCategoryDecl::protocol_iterator
139 I = OCD->protocol_begin(), E = OCD->protocol_end(); I != E; ++I)
140 if (ObjCPropertyDecl *P = (*I)->FindPropertyDeclaration(PropertyId))
149 /// FindPropertyVisibleInPrimaryClass - Finds declaration of the property
150 /// with name 'PropertyId' in the primary class; including those in protocols
151 /// (direct or indirect) used by the primary class.
154 ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass(
155 IdentifierInfo *PropertyId) const {
156 if (ExternallyCompleted)
157 LoadExternalDefinition();
159 if (ObjCPropertyDecl *PD =
160 ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(this), PropertyId))
163 // Look through protocols.
164 for (ObjCInterfaceDecl::all_protocol_iterator
165 I = all_referenced_protocol_begin(),
166 E = all_referenced_protocol_end(); I != E; ++I)
167 if (ObjCPropertyDecl *P = (*I)->FindPropertyDeclaration(PropertyId))
173 void ObjCInterfaceDecl::mergeClassExtensionProtocolList(
174 ObjCProtocolDecl *const* ExtList, unsigned ExtNum,
177 if (ExternallyCompleted)
178 LoadExternalDefinition();
180 if (AllReferencedProtocols.empty() && ReferencedProtocols.empty()) {
181 AllReferencedProtocols.set(ExtList, ExtNum, C);
185 // Check for duplicate protocol in class's protocol list.
186 // This is O(n*m). But it is extremely rare and number of protocols in
187 // class or its extension are very few.
188 llvm::SmallVector<ObjCProtocolDecl*, 8> ProtocolRefs;
189 for (unsigned i = 0; i < ExtNum; i++) {
190 bool protocolExists = false;
191 ObjCProtocolDecl *ProtoInExtension = ExtList[i];
192 for (all_protocol_iterator
193 p = all_referenced_protocol_begin(),
194 e = all_referenced_protocol_end(); p != e; ++p) {
195 ObjCProtocolDecl *Proto = (*p);
196 if (C.ProtocolCompatibleWithProtocol(ProtoInExtension, Proto)) {
197 protocolExists = true;
201 // Do we want to warn on a protocol in extension class which
202 // already exist in the class? Probably not.
204 ProtocolRefs.push_back(ProtoInExtension);
207 if (ProtocolRefs.empty())
210 // Merge ProtocolRefs into class's protocol list;
211 for (all_protocol_iterator p = all_referenced_protocol_begin(),
212 e = all_referenced_protocol_end(); p != e; ++p) {
213 ProtocolRefs.push_back(*p);
216 AllReferencedProtocols.set(ProtocolRefs.data(), ProtocolRefs.size(), C);
219 /// getFirstClassExtension - Find first class extension of the given class.
220 ObjCCategoryDecl* ObjCInterfaceDecl::getFirstClassExtension() const {
221 for (ObjCCategoryDecl *CDecl = getCategoryList(); CDecl;
222 CDecl = CDecl->getNextClassCategory())
223 if (CDecl->IsClassExtension())
228 /// getNextClassCategory - Find next class extension in list of categories.
229 const ObjCCategoryDecl* ObjCCategoryDecl::getNextClassExtension() const {
230 for (const ObjCCategoryDecl *CDecl = getNextClassCategory(); CDecl;
231 CDecl = CDecl->getNextClassCategory())
232 if (CDecl->IsClassExtension())
237 ObjCIvarDecl *ObjCInterfaceDecl::lookupInstanceVariable(IdentifierInfo *ID,
238 ObjCInterfaceDecl *&clsDeclared) {
239 ObjCInterfaceDecl* ClassDecl = this;
240 while (ClassDecl != NULL) {
241 if (ObjCIvarDecl *I = ClassDecl->getIvarDecl(ID)) {
242 clsDeclared = ClassDecl;
245 for (const ObjCCategoryDecl *CDecl = ClassDecl->getFirstClassExtension();
246 CDecl; CDecl = CDecl->getNextClassExtension()) {
247 if (ObjCIvarDecl *I = CDecl->getIvarDecl(ID)) {
248 clsDeclared = ClassDecl;
253 ClassDecl = ClassDecl->getSuperClass();
258 /// lookupInheritedClass - This method returns ObjCInterfaceDecl * of the super
259 /// class whose name is passed as argument. If it is not one of the super classes
260 /// the it returns NULL.
261 ObjCInterfaceDecl *ObjCInterfaceDecl::lookupInheritedClass(
262 const IdentifierInfo*ICName) {
263 ObjCInterfaceDecl* ClassDecl = this;
264 while (ClassDecl != NULL) {
265 if (ClassDecl->getIdentifier() == ICName)
267 ClassDecl = ClassDecl->getSuperClass();
272 /// lookupMethod - This method returns an instance/class method by looking in
273 /// the class, its categories, and its super classes (using a linear search).
274 ObjCMethodDecl *ObjCInterfaceDecl::lookupMethod(Selector Sel,
275 bool isInstance) const {
276 const ObjCInterfaceDecl* ClassDecl = this;
277 ObjCMethodDecl *MethodDecl = 0;
279 if (ExternallyCompleted)
280 LoadExternalDefinition();
282 while (ClassDecl != NULL) {
283 if ((MethodDecl = ClassDecl->getMethod(Sel, isInstance)))
286 // Didn't find one yet - look through protocols.
287 const ObjCList<ObjCProtocolDecl> &Protocols =
288 ClassDecl->getReferencedProtocols();
289 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
290 E = Protocols.end(); I != E; ++I)
291 if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance)))
294 // Didn't find one yet - now look through categories.
295 ObjCCategoryDecl *CatDecl = ClassDecl->getCategoryList();
297 if ((MethodDecl = CatDecl->getMethod(Sel, isInstance)))
300 // Didn't find one yet - look through protocols.
301 const ObjCList<ObjCProtocolDecl> &Protocols =
302 CatDecl->getReferencedProtocols();
303 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
304 E = Protocols.end(); I != E; ++I)
305 if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance)))
307 CatDecl = CatDecl->getNextClassCategory();
309 ClassDecl = ClassDecl->getSuperClass();
314 ObjCMethodDecl *ObjCInterfaceDecl::lookupPrivateMethod(
317 ObjCMethodDecl *Method = 0;
318 if (ObjCImplementationDecl *ImpDecl = getImplementation())
319 Method = Instance ? ImpDecl->getInstanceMethod(Sel)
320 : ImpDecl->getClassMethod(Sel);
322 if (!Method && getSuperClass())
323 return getSuperClass()->lookupPrivateMethod(Sel, Instance);
327 //===----------------------------------------------------------------------===//
329 //===----------------------------------------------------------------------===//
331 ObjCMethodDecl *ObjCMethodDecl::Create(ASTContext &C,
332 SourceLocation beginLoc,
333 SourceLocation endLoc,
334 Selector SelInfo, QualType T,
335 TypeSourceInfo *ResultTInfo,
336 DeclContext *contextDecl,
341 ImplementationControl impControl,
342 bool HasRelatedResultType,
343 unsigned numSelectorArgs) {
344 return new (C) ObjCMethodDecl(beginLoc, endLoc,
345 SelInfo, T, ResultTInfo, contextDecl,
347 isVariadic, isSynthesized, isDefined,
349 HasRelatedResultType,
353 /// \brief A definition will return its interface declaration.
354 /// An interface declaration will return its definition.
355 /// Otherwise it will return itself.
356 ObjCMethodDecl *ObjCMethodDecl::getNextRedeclaration() {
357 ASTContext &Ctx = getASTContext();
358 ObjCMethodDecl *Redecl = 0;
359 Decl *CtxD = cast<Decl>(getDeclContext());
361 if (ObjCInterfaceDecl *IFD = dyn_cast<ObjCInterfaceDecl>(CtxD)) {
362 if (ObjCImplementationDecl *ImplD = Ctx.getObjCImplementation(IFD))
363 Redecl = ImplD->getMethod(getSelector(), isInstanceMethod());
365 } else if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CtxD)) {
366 if (ObjCCategoryImplDecl *ImplD = Ctx.getObjCImplementation(CD))
367 Redecl = ImplD->getMethod(getSelector(), isInstanceMethod());
369 } else if (ObjCImplementationDecl *ImplD =
370 dyn_cast<ObjCImplementationDecl>(CtxD)) {
371 if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
372 Redecl = IFD->getMethod(getSelector(), isInstanceMethod());
374 } else if (ObjCCategoryImplDecl *CImplD =
375 dyn_cast<ObjCCategoryImplDecl>(CtxD)) {
376 if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl())
377 Redecl = CatD->getMethod(getSelector(), isInstanceMethod());
380 return Redecl ? Redecl : this;
383 ObjCMethodDecl *ObjCMethodDecl::getCanonicalDecl() {
384 Decl *CtxD = cast<Decl>(getDeclContext());
386 if (ObjCImplementationDecl *ImplD = dyn_cast<ObjCImplementationDecl>(CtxD)) {
387 if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
388 if (ObjCMethodDecl *MD = IFD->getMethod(getSelector(),
392 } else if (ObjCCategoryImplDecl *CImplD =
393 dyn_cast<ObjCCategoryImplDecl>(CtxD)) {
394 if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl())
395 if (ObjCMethodDecl *MD = CatD->getMethod(getSelector(),
403 ObjCMethodFamily ObjCMethodDecl::getMethodFamily() const {
404 ObjCMethodFamily family = static_cast<ObjCMethodFamily>(Family);
405 if (family != static_cast<unsigned>(InvalidObjCMethodFamily))
408 // Check for an explicit attribute.
409 if (const ObjCMethodFamilyAttr *attr = getAttr<ObjCMethodFamilyAttr>()) {
410 // The unfortunate necessity of mapping between enums here is due
411 // to the attributes framework.
412 switch (attr->getFamily()) {
413 case ObjCMethodFamilyAttr::OMF_None: family = OMF_None; break;
414 case ObjCMethodFamilyAttr::OMF_alloc: family = OMF_alloc; break;
415 case ObjCMethodFamilyAttr::OMF_copy: family = OMF_copy; break;
416 case ObjCMethodFamilyAttr::OMF_init: family = OMF_init; break;
417 case ObjCMethodFamilyAttr::OMF_mutableCopy: family = OMF_mutableCopy; break;
418 case ObjCMethodFamilyAttr::OMF_new: family = OMF_new; break;
420 Family = static_cast<unsigned>(family);
424 family = getSelector().getMethodFamily();
426 case OMF_None: break;
428 // init only has a conventional meaning for an instance method, and
429 // it has to return an object.
431 if (!isInstanceMethod() || !getResultType()->isObjCObjectPointerType())
435 // alloc/copy/new have a conventional meaning for both class and
436 // instance methods, but they require an object return.
439 case OMF_mutableCopy:
441 if (!getResultType()->isObjCObjectPointerType())
445 // These selectors have a conventional meaning only for instance methods.
449 case OMF_autorelease:
450 case OMF_retainCount:
452 if (!isInstanceMethod())
456 case OMF_performSelector:
457 if (!isInstanceMethod() ||
458 !getResultType()->isObjCIdType())
461 unsigned noParams = param_size();
462 if (noParams < 1 || noParams > 3)
465 ObjCMethodDecl::arg_type_iterator it = arg_type_begin();
466 QualType ArgT = (*it);
467 if (!ArgT->isObjCSelType()) {
474 if (!ArgT->isObjCIdType()) {
486 Family = static_cast<unsigned>(family);
490 void ObjCMethodDecl::createImplicitParams(ASTContext &Context,
491 const ObjCInterfaceDecl *OID) {
493 if (isInstanceMethod()) {
494 // There may be no interface context due to error in declaration
495 // of the interface (which has been reported). Recover gracefully.
497 selfTy = Context.getObjCInterfaceType(OID);
498 selfTy = Context.getObjCObjectPointerType(selfTy);
500 selfTy = Context.getObjCIdType();
502 } else // we have a factory method.
503 selfTy = Context.getObjCClassType();
505 bool selfIsPseudoStrong = false;
506 bool selfIsConsumed = false;
507 if (isInstanceMethod() && Context.getLangOptions().ObjCAutoRefCount) {
508 selfIsConsumed = hasAttr<NSConsumesSelfAttr>();
510 // 'self' is always __strong. It's actually pseudo-strong except
511 // in init methods, though.
513 qs.setObjCLifetime(Qualifiers::OCL_Strong);
514 selfTy = Context.getQualifiedType(selfTy, qs);
516 // In addition, 'self' is const unless this is an init method.
517 if (getMethodFamily() != OMF_init) {
518 selfTy = selfTy.withConst();
519 selfIsPseudoStrong = true;
523 ImplicitParamDecl *self
524 = ImplicitParamDecl::Create(Context, this, SourceLocation(),
525 &Context.Idents.get("self"), selfTy);
529 self->addAttr(new (Context) NSConsumedAttr(SourceLocation(), Context));
531 if (selfIsPseudoStrong)
532 self->setARCPseudoStrong(true);
534 setCmdDecl(ImplicitParamDecl::Create(Context, this, SourceLocation(),
535 &Context.Idents.get("_cmd"),
536 Context.getObjCSelType()));
539 ObjCInterfaceDecl *ObjCMethodDecl::getClassInterface() {
540 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(getDeclContext()))
542 if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(getDeclContext()))
543 return CD->getClassInterface();
544 if (ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(getDeclContext()))
545 return IMD->getClassInterface();
547 assert(!isa<ObjCProtocolDecl>(getDeclContext()) && "It's a protocol method");
548 assert(false && "unknown method context");
552 //===----------------------------------------------------------------------===//
554 //===----------------------------------------------------------------------===//
556 ObjCInterfaceDecl *ObjCInterfaceDecl::Create(ASTContext &C,
558 SourceLocation atLoc,
560 SourceLocation ClassLoc,
561 bool ForwardDecl, bool isInternal){
562 return new (C) ObjCInterfaceDecl(DC, atLoc, Id, ClassLoc, ForwardDecl,
567 ObjCInterfaceDecl(DeclContext *DC, SourceLocation atLoc, IdentifierInfo *Id,
568 SourceLocation CLoc, bool FD, bool isInternal)
569 : ObjCContainerDecl(ObjCInterface, DC, atLoc, Id),
570 TypeForDecl(0), SuperClass(0),
571 CategoryList(0), IvarList(0),
572 ForwardDecl(FD), InternalInterface(isInternal), ExternallyCompleted(false),
576 void ObjCInterfaceDecl::LoadExternalDefinition() const {
577 assert(ExternallyCompleted && "Class is not externally completed");
578 ExternallyCompleted = false;
579 getASTContext().getExternalSource()->CompleteType(
580 const_cast<ObjCInterfaceDecl *>(this));
583 void ObjCInterfaceDecl::setExternallyCompleted() {
584 assert(getASTContext().getExternalSource() &&
585 "Class can't be externally completed without an external source");
586 assert(!ForwardDecl &&
587 "Forward declarations can't be externally completed");
588 ExternallyCompleted = true;
591 ObjCImplementationDecl *ObjCInterfaceDecl::getImplementation() const {
592 if (ExternallyCompleted)
593 LoadExternalDefinition();
595 return getASTContext().getObjCImplementation(
596 const_cast<ObjCInterfaceDecl*>(this));
599 void ObjCInterfaceDecl::setImplementation(ObjCImplementationDecl *ImplD) {
600 getASTContext().setObjCImplementation(this, ImplD);
603 /// all_declared_ivar_begin - return first ivar declared in this class,
604 /// its extensions and its implementation. Lazily build the list on first
606 ObjCIvarDecl *ObjCInterfaceDecl::all_declared_ivar_begin() {
610 ObjCIvarDecl *curIvar = 0;
612 ObjCInterfaceDecl::ivar_iterator I = ivar_begin(), E = ivar_end();
613 IvarList = (*I); ++I;
614 for (curIvar = IvarList; I != E; curIvar = *I, ++I)
615 curIvar->setNextIvar(*I);
618 for (const ObjCCategoryDecl *CDecl = getFirstClassExtension(); CDecl;
619 CDecl = CDecl->getNextClassExtension()) {
620 if (!CDecl->ivar_empty()) {
621 ObjCCategoryDecl::ivar_iterator I = CDecl->ivar_begin(),
622 E = CDecl->ivar_end();
624 IvarList = (*I); ++I;
627 for ( ;I != E; curIvar = *I, ++I)
628 curIvar->setNextIvar(*I);
632 if (ObjCImplementationDecl *ImplDecl = getImplementation()) {
633 if (!ImplDecl->ivar_empty()) {
634 ObjCImplementationDecl::ivar_iterator I = ImplDecl->ivar_begin(),
635 E = ImplDecl->ivar_end();
637 IvarList = (*I); ++I;
640 for ( ;I != E; curIvar = *I, ++I)
641 curIvar->setNextIvar(*I);
647 /// FindCategoryDeclaration - Finds category declaration in the list of
648 /// categories for this class and returns it. Name of the category is passed
649 /// in 'CategoryId'. If category not found, return 0;
652 ObjCInterfaceDecl::FindCategoryDeclaration(IdentifierInfo *CategoryId) const {
653 if (ExternallyCompleted)
654 LoadExternalDefinition();
656 for (ObjCCategoryDecl *Category = getCategoryList();
657 Category; Category = Category->getNextClassCategory())
658 if (Category->getIdentifier() == CategoryId)
664 ObjCInterfaceDecl::getCategoryInstanceMethod(Selector Sel) const {
665 for (ObjCCategoryDecl *Category = getCategoryList();
666 Category; Category = Category->getNextClassCategory())
667 if (ObjCCategoryImplDecl *Impl = Category->getImplementation())
668 if (ObjCMethodDecl *MD = Impl->getInstanceMethod(Sel))
673 ObjCMethodDecl *ObjCInterfaceDecl::getCategoryClassMethod(Selector Sel) const {
674 for (ObjCCategoryDecl *Category = getCategoryList();
675 Category; Category = Category->getNextClassCategory())
676 if (ObjCCategoryImplDecl *Impl = Category->getImplementation())
677 if (ObjCMethodDecl *MD = Impl->getClassMethod(Sel))
682 /// ClassImplementsProtocol - Checks that 'lProto' protocol
683 /// has been implemented in IDecl class, its super class or categories (if
684 /// lookupCategory is true).
685 bool ObjCInterfaceDecl::ClassImplementsProtocol(ObjCProtocolDecl *lProto,
687 bool RHSIsQualifiedID) {
688 ObjCInterfaceDecl *IDecl = this;
689 // 1st, look up the class.
690 const ObjCList<ObjCProtocolDecl> &Protocols =
691 IDecl->getReferencedProtocols();
693 for (ObjCList<ObjCProtocolDecl>::iterator PI = Protocols.begin(),
694 E = Protocols.end(); PI != E; ++PI) {
695 if (getASTContext().ProtocolCompatibleWithProtocol(lProto, *PI))
697 // This is dubious and is added to be compatible with gcc. In gcc, it is
698 // also allowed assigning a protocol-qualified 'id' type to a LHS object
699 // when protocol in qualified LHS is in list of protocols in the rhs 'id'
700 // object. This IMO, should be a bug.
701 // FIXME: Treat this as an extension, and flag this as an error when GCC
702 // extensions are not enabled.
703 if (RHSIsQualifiedID &&
704 getASTContext().ProtocolCompatibleWithProtocol(*PI, lProto))
708 // 2nd, look up the category.
710 for (ObjCCategoryDecl *CDecl = IDecl->getCategoryList(); CDecl;
711 CDecl = CDecl->getNextClassCategory()) {
712 for (ObjCCategoryDecl::protocol_iterator PI = CDecl->protocol_begin(),
713 E = CDecl->protocol_end(); PI != E; ++PI)
714 if (getASTContext().ProtocolCompatibleWithProtocol(lProto, *PI))
718 // 3rd, look up the super class(s)
719 if (IDecl->getSuperClass())
721 IDecl->getSuperClass()->ClassImplementsProtocol(lProto, lookupCategory,
727 //===----------------------------------------------------------------------===//
729 //===----------------------------------------------------------------------===//
731 ObjCIvarDecl *ObjCIvarDecl::Create(ASTContext &C, ObjCContainerDecl *DC,
732 SourceLocation StartLoc,
733 SourceLocation IdLoc, IdentifierInfo *Id,
734 QualType T, TypeSourceInfo *TInfo,
735 AccessControl ac, Expr *BW,
738 // Ivar's can only appear in interfaces, implementations (via synthesized
739 // properties), and class extensions (via direct declaration, or synthesized
742 // FIXME: This should really be asserting this:
743 // (isa<ObjCCategoryDecl>(DC) &&
744 // cast<ObjCCategoryDecl>(DC)->IsClassExtension()))
745 // but unfortunately we sometimes place ivars into non-class extension
746 // categories on error. This breaks an AST invariant, and should not be
748 assert((isa<ObjCInterfaceDecl>(DC) || isa<ObjCImplementationDecl>(DC) ||
749 isa<ObjCCategoryDecl>(DC)) &&
750 "Invalid ivar decl context!");
751 // Once a new ivar is created in any of class/class-extension/implementation
752 // decl contexts, the previously built IvarList must be rebuilt.
753 ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(DC);
755 if (ObjCImplementationDecl *IM = dyn_cast<ObjCImplementationDecl>(DC)) {
756 ID = IM->getClassInterface();
758 IM->setHasSynthBitfield(true);
761 ObjCCategoryDecl *CD = cast<ObjCCategoryDecl>(DC);
762 ID = CD->getClassInterface();
764 CD->setHasSynthBitfield(true);
770 return new (C) ObjCIvarDecl(DC, StartLoc, IdLoc, Id, T, TInfo,
771 ac, BW, synthesized);
774 const ObjCInterfaceDecl *ObjCIvarDecl::getContainingInterface() const {
775 const ObjCContainerDecl *DC = cast<ObjCContainerDecl>(getDeclContext());
777 switch (DC->getKind()) {
779 case ObjCCategoryImpl:
781 assert(0 && "invalid ivar container!");
784 // Ivars can only appear in class extension categories.
786 const ObjCCategoryDecl *CD = cast<ObjCCategoryDecl>(DC);
787 assert(CD->IsClassExtension() && "invalid container for ivar!");
788 return CD->getClassInterface();
791 case ObjCImplementation:
792 return cast<ObjCImplementationDecl>(DC)->getClassInterface();
795 return cast<ObjCInterfaceDecl>(DC);
799 //===----------------------------------------------------------------------===//
800 // ObjCAtDefsFieldDecl
801 //===----------------------------------------------------------------------===//
804 *ObjCAtDefsFieldDecl::Create(ASTContext &C, DeclContext *DC,
805 SourceLocation StartLoc, SourceLocation IdLoc,
806 IdentifierInfo *Id, QualType T, Expr *BW) {
807 return new (C) ObjCAtDefsFieldDecl(DC, StartLoc, IdLoc, Id, T, BW);
810 //===----------------------------------------------------------------------===//
812 //===----------------------------------------------------------------------===//
814 ObjCProtocolDecl *ObjCProtocolDecl::Create(ASTContext &C, DeclContext *DC,
816 IdentifierInfo *Id) {
817 return new (C) ObjCProtocolDecl(DC, L, Id);
820 ObjCProtocolDecl *ObjCProtocolDecl::lookupProtocolNamed(IdentifierInfo *Name) {
821 ObjCProtocolDecl *PDecl = this;
823 if (Name == getIdentifier())
826 for (protocol_iterator I = protocol_begin(), E = protocol_end(); I != E; ++I)
827 if ((PDecl = (*I)->lookupProtocolNamed(Name)))
833 // lookupMethod - Lookup a instance/class method in the protocol and protocols
835 ObjCMethodDecl *ObjCProtocolDecl::lookupMethod(Selector Sel,
836 bool isInstance) const {
837 ObjCMethodDecl *MethodDecl = NULL;
839 if ((MethodDecl = getMethod(Sel, isInstance)))
842 for (protocol_iterator I = protocol_begin(), E = protocol_end(); I != E; ++I)
843 if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance)))
848 //===----------------------------------------------------------------------===//
850 //===----------------------------------------------------------------------===//
852 ObjCClassDecl::ObjCClassDecl(DeclContext *DC, SourceLocation L,
853 ObjCInterfaceDecl *const *Elts,
854 const SourceLocation *Locs,
857 : Decl(ObjCClass, DC, L) {
858 setClassList(C, Elts, Locs, nElts);
861 void ObjCClassDecl::setClassList(ASTContext &C, ObjCInterfaceDecl*const*List,
862 const SourceLocation *Locs, unsigned Num) {
863 ForwardDecls = (ObjCClassRef*) C.Allocate(sizeof(ObjCClassRef)*Num,
864 llvm::alignOf<ObjCClassRef>());
865 for (unsigned i = 0; i < Num; ++i)
866 new (&ForwardDecls[i]) ObjCClassRef(List[i], Locs[i]);
871 ObjCClassDecl *ObjCClassDecl::Create(ASTContext &C, DeclContext *DC,
873 ObjCInterfaceDecl *const *Elts,
874 const SourceLocation *Locs,
876 return new (C) ObjCClassDecl(DC, L, Elts, Locs, nElts, C);
879 SourceRange ObjCClassDecl::getSourceRange() const {
880 // FIXME: We should include the semicolon
882 return SourceRange(getLocation(), ForwardDecls[NumDecls-1].getLocation());
885 //===----------------------------------------------------------------------===//
886 // ObjCForwardProtocolDecl
887 //===----------------------------------------------------------------------===//
889 ObjCForwardProtocolDecl::
890 ObjCForwardProtocolDecl(DeclContext *DC, SourceLocation L,
891 ObjCProtocolDecl *const *Elts, unsigned nElts,
892 const SourceLocation *Locs, ASTContext &C)
893 : Decl(ObjCForwardProtocol, DC, L) {
894 ReferencedProtocols.set(Elts, nElts, Locs, C);
898 ObjCForwardProtocolDecl *
899 ObjCForwardProtocolDecl::Create(ASTContext &C, DeclContext *DC,
901 ObjCProtocolDecl *const *Elts,
903 const SourceLocation *Locs) {
904 return new (C) ObjCForwardProtocolDecl(DC, L, Elts, NumElts, Locs, C);
907 //===----------------------------------------------------------------------===//
909 //===----------------------------------------------------------------------===//
911 ObjCCategoryDecl *ObjCCategoryDecl::Create(ASTContext &C, DeclContext *DC,
912 SourceLocation AtLoc,
913 SourceLocation ClassNameLoc,
914 SourceLocation CategoryNameLoc,
915 IdentifierInfo *Id) {
916 return new (C) ObjCCategoryDecl(DC, AtLoc, ClassNameLoc, CategoryNameLoc, Id);
919 ObjCCategoryImplDecl *ObjCCategoryDecl::getImplementation() const {
920 return getASTContext().getObjCImplementation(
921 const_cast<ObjCCategoryDecl*>(this));
924 void ObjCCategoryDecl::setImplementation(ObjCCategoryImplDecl *ImplD) {
925 getASTContext().setObjCImplementation(this, ImplD);
929 //===----------------------------------------------------------------------===//
930 // ObjCCategoryImplDecl
931 //===----------------------------------------------------------------------===//
933 ObjCCategoryImplDecl *
934 ObjCCategoryImplDecl::Create(ASTContext &C, DeclContext *DC,
935 SourceLocation L,IdentifierInfo *Id,
936 ObjCInterfaceDecl *ClassInterface) {
937 return new (C) ObjCCategoryImplDecl(DC, L, Id, ClassInterface);
940 ObjCCategoryDecl *ObjCCategoryImplDecl::getCategoryDecl() const {
941 // The class interface might be NULL if we are working with invalid code.
942 if (const ObjCInterfaceDecl *ID = getClassInterface())
943 return ID->FindCategoryDeclaration(getIdentifier());
948 void ObjCImplDecl::addPropertyImplementation(ObjCPropertyImplDecl *property) {
949 // FIXME: The context should be correct before we get here.
950 property->setLexicalDeclContext(this);
954 void ObjCImplDecl::setClassInterface(ObjCInterfaceDecl *IFace) {
955 ASTContext &Ctx = getASTContext();
957 if (ObjCImplementationDecl *ImplD
958 = dyn_cast_or_null<ObjCImplementationDecl>(this)) {
960 Ctx.setObjCImplementation(IFace, ImplD);
962 } else if (ObjCCategoryImplDecl *ImplD =
963 dyn_cast_or_null<ObjCCategoryImplDecl>(this)) {
964 if (ObjCCategoryDecl *CD = IFace->FindCategoryDeclaration(getIdentifier()))
965 Ctx.setObjCImplementation(CD, ImplD);
968 ClassInterface = IFace;
971 /// FindPropertyImplIvarDecl - This method lookup the ivar in the list of
972 /// properties implemented in this category @implementation block and returns
973 /// the implemented property that uses it.
975 ObjCPropertyImplDecl *ObjCImplDecl::
976 FindPropertyImplIvarDecl(IdentifierInfo *ivarId) const {
977 for (propimpl_iterator i = propimpl_begin(), e = propimpl_end(); i != e; ++i){
978 ObjCPropertyImplDecl *PID = *i;
979 if (PID->getPropertyIvarDecl() &&
980 PID->getPropertyIvarDecl()->getIdentifier() == ivarId)
986 /// FindPropertyImplDecl - This method looks up a previous ObjCPropertyImplDecl
987 /// added to the list of those properties @synthesized/@dynamic in this
988 /// category @implementation block.
990 ObjCPropertyImplDecl *ObjCImplDecl::
991 FindPropertyImplDecl(IdentifierInfo *Id) const {
992 for (propimpl_iterator i = propimpl_begin(), e = propimpl_end(); i != e; ++i){
993 ObjCPropertyImplDecl *PID = *i;
994 if (PID->getPropertyDecl()->getIdentifier() == Id)
1000 llvm::raw_ostream &clang::operator<<(llvm::raw_ostream &OS,
1001 const ObjCCategoryImplDecl *CID) {
1002 OS << CID->getName();
1006 //===----------------------------------------------------------------------===//
1007 // ObjCImplementationDecl
1008 //===----------------------------------------------------------------------===//
1010 ObjCImplementationDecl *
1011 ObjCImplementationDecl::Create(ASTContext &C, DeclContext *DC,
1013 ObjCInterfaceDecl *ClassInterface,
1014 ObjCInterfaceDecl *SuperDecl) {
1015 return new (C) ObjCImplementationDecl(DC, L, ClassInterface, SuperDecl);
1018 llvm::raw_ostream &clang::operator<<(llvm::raw_ostream &OS,
1019 const ObjCImplementationDecl *ID) {
1020 OS << ID->getName();
1024 //===----------------------------------------------------------------------===//
1025 // ObjCCompatibleAliasDecl
1026 //===----------------------------------------------------------------------===//
1028 ObjCCompatibleAliasDecl *
1029 ObjCCompatibleAliasDecl::Create(ASTContext &C, DeclContext *DC,
1032 ObjCInterfaceDecl* AliasedClass) {
1033 return new (C) ObjCCompatibleAliasDecl(DC, L, Id, AliasedClass);
1036 //===----------------------------------------------------------------------===//
1038 //===----------------------------------------------------------------------===//
1040 ObjCPropertyDecl *ObjCPropertyDecl::Create(ASTContext &C, DeclContext *DC,
1043 SourceLocation AtLoc,
1045 PropertyControl propControl) {
1046 return new (C) ObjCPropertyDecl(DC, L, Id, AtLoc, T);
1049 //===----------------------------------------------------------------------===//
1050 // ObjCPropertyImplDecl
1051 //===----------------------------------------------------------------------===//
1053 ObjCPropertyImplDecl *ObjCPropertyImplDecl::Create(ASTContext &C,
1055 SourceLocation atLoc,
1057 ObjCPropertyDecl *property,
1060 SourceLocation ivarLoc) {
1061 return new (C) ObjCPropertyImplDecl(DC, atLoc, L, property, PK, ivar,
1065 SourceRange ObjCPropertyImplDecl::getSourceRange() const {
1066 SourceLocation EndLoc = getLocation();
1067 if (IvarLoc.isValid())
1070 return SourceRange(AtLoc, EndLoc);