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