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/Stmt.h" 17 #include "clang/AST/ASTMutationListener.h" 18 #include "llvm/ADT/STLExtras.h" 19 using namespace clang; 20 21 //===----------------------------------------------------------------------===// 22 // ObjCListBase 23 //===----------------------------------------------------------------------===// 24 25 void ObjCListBase::set(void *const* InList, unsigned Elts, ASTContext &Ctx) { 26 List = 0; 27 if (Elts == 0) return; // Setting to an empty list is a noop. 28 29 30 List = new (Ctx) void*[Elts]; 31 NumElts = Elts; 32 memcpy(List, InList, sizeof(void*)*Elts); 33 } 34 35 void ObjCProtocolList::set(ObjCProtocolDecl* const* InList, unsigned Elts, 36 const SourceLocation *Locs, ASTContext &Ctx) { 37 if (Elts == 0) 38 return; 39 40 Locations = new (Ctx) SourceLocation[Elts]; 41 memcpy(Locations, Locs, sizeof(SourceLocation) * Elts); 42 set(InList, Elts, Ctx); 43 } 44 45 //===----------------------------------------------------------------------===// 46 // ObjCInterfaceDecl 47 //===----------------------------------------------------------------------===// 48 49 void ObjCContainerDecl::anchor() { } 50 51 /// getIvarDecl - This method looks up an ivar in this ContextDecl. 52 /// 53 ObjCIvarDecl * 54 ObjCContainerDecl::getIvarDecl(IdentifierInfo *Id) const { 55 lookup_const_iterator Ivar, IvarEnd; 56 for (llvm::tie(Ivar, IvarEnd) = lookup(Id); Ivar != IvarEnd; ++Ivar) { 57 if (ObjCIvarDecl *ivar = dyn_cast<ObjCIvarDecl>(*Ivar)) 58 return ivar; 59 } 60 return 0; 61 } 62 63 // Get the local instance/class method declared in this interface. 64 ObjCMethodDecl * 65 ObjCContainerDecl::getMethod(Selector Sel, bool isInstance) const { 66 // Since instance & class methods can have the same name, the loop below 67 // ensures we get the correct method. 68 // 69 // @interface Whatever 70 // - (int) class_method; 71 // + (float) class_method; 72 // @end 73 // 74 lookup_const_iterator Meth, MethEnd; 75 for (llvm::tie(Meth, MethEnd) = lookup(Sel); Meth != MethEnd; ++Meth) { 76 ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(*Meth); 77 if (MD && MD->isInstanceMethod() == isInstance) 78 return MD; 79 } 80 return 0; 81 } 82 83 ObjCPropertyDecl * 84 ObjCPropertyDecl::findPropertyDecl(const DeclContext *DC, 85 IdentifierInfo *propertyID) { 86 87 DeclContext::lookup_const_iterator I, E; 88 llvm::tie(I, E) = DC->lookup(propertyID); 89 for ( ; I != E; ++I) 90 if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(*I)) 91 return PD; 92 93 return 0; 94 } 95 96 /// FindPropertyDeclaration - Finds declaration of the property given its name 97 /// in 'PropertyId' and returns it. It returns 0, if not found. 98 ObjCPropertyDecl * 99 ObjCContainerDecl::FindPropertyDeclaration(IdentifierInfo *PropertyId) const { 100 101 if (ObjCPropertyDecl *PD = 102 ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(this), PropertyId)) 103 return PD; 104 105 switch (getKind()) { 106 default: 107 break; 108 case Decl::ObjCProtocol: { 109 const ObjCProtocolDecl *PID = cast<ObjCProtocolDecl>(this); 110 for (ObjCProtocolDecl::protocol_iterator I = PID->protocol_begin(), 111 E = PID->protocol_end(); I != E; ++I) 112 if (ObjCPropertyDecl *P = (*I)->FindPropertyDeclaration(PropertyId)) 113 return P; 114 break; 115 } 116 case Decl::ObjCInterface: { 117 const ObjCInterfaceDecl *OID = cast<ObjCInterfaceDecl>(this); 118 // Look through categories. 119 for (ObjCCategoryDecl *Cat = OID->getCategoryList(); 120 Cat; Cat = Cat->getNextClassCategory()) 121 if (!Cat->IsClassExtension()) 122 if (ObjCPropertyDecl *P = Cat->FindPropertyDeclaration(PropertyId)) 123 return P; 124 125 // Look through protocols. 126 for (ObjCInterfaceDecl::all_protocol_iterator 127 I = OID->all_referenced_protocol_begin(), 128 E = OID->all_referenced_protocol_end(); I != E; ++I) 129 if (ObjCPropertyDecl *P = (*I)->FindPropertyDeclaration(PropertyId)) 130 return P; 131 132 // Finally, check the super class. 133 if (const ObjCInterfaceDecl *superClass = OID->getSuperClass()) 134 return superClass->FindPropertyDeclaration(PropertyId); 135 break; 136 } 137 case Decl::ObjCCategory: { 138 const ObjCCategoryDecl *OCD = cast<ObjCCategoryDecl>(this); 139 // Look through protocols. 140 if (!OCD->IsClassExtension()) 141 for (ObjCCategoryDecl::protocol_iterator 142 I = OCD->protocol_begin(), E = OCD->protocol_end(); I != E; ++I) 143 if (ObjCPropertyDecl *P = (*I)->FindPropertyDeclaration(PropertyId)) 144 return P; 145 146 break; 147 } 148 } 149 return 0; 150 } 151 152 void ObjCInterfaceDecl::anchor() { } 153 154 /// FindPropertyVisibleInPrimaryClass - Finds declaration of the property 155 /// with name 'PropertyId' in the primary class; including those in protocols 156 /// (direct or indirect) used by the primary class. 157 /// 158 ObjCPropertyDecl * 159 ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass( 160 IdentifierInfo *PropertyId) const { 161 // FIXME: Should make sure no callers ever do this. 162 if (!hasDefinition()) 163 return 0; 164 165 if (data().ExternallyCompleted) 166 LoadExternalDefinition(); 167 168 if (ObjCPropertyDecl *PD = 169 ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(this), PropertyId)) 170 return PD; 171 172 // Look through protocols. 173 for (ObjCInterfaceDecl::all_protocol_iterator 174 I = all_referenced_protocol_begin(), 175 E = all_referenced_protocol_end(); I != E; ++I) 176 if (ObjCPropertyDecl *P = (*I)->FindPropertyDeclaration(PropertyId)) 177 return P; 178 179 return 0; 180 } 181 182 void ObjCInterfaceDecl::mergeClassExtensionProtocolList( 183 ObjCProtocolDecl *const* ExtList, unsigned ExtNum, 184 ASTContext &C) 185 { 186 if (data().ExternallyCompleted) 187 LoadExternalDefinition(); 188 189 if (data().AllReferencedProtocols.empty() && 190 data().ReferencedProtocols.empty()) { 191 data().AllReferencedProtocols.set(ExtList, ExtNum, C); 192 return; 193 } 194 195 // Check for duplicate protocol in class's protocol list. 196 // This is O(n*m). But it is extremely rare and number of protocols in 197 // class or its extension are very few. 198 SmallVector<ObjCProtocolDecl*, 8> ProtocolRefs; 199 for (unsigned i = 0; i < ExtNum; i++) { 200 bool protocolExists = false; 201 ObjCProtocolDecl *ProtoInExtension = ExtList[i]; 202 for (all_protocol_iterator 203 p = all_referenced_protocol_begin(), 204 e = all_referenced_protocol_end(); p != e; ++p) { 205 ObjCProtocolDecl *Proto = (*p); 206 if (C.ProtocolCompatibleWithProtocol(ProtoInExtension, Proto)) { 207 protocolExists = true; 208 break; 209 } 210 } 211 // Do we want to warn on a protocol in extension class which 212 // already exist in the class? Probably not. 213 if (!protocolExists) 214 ProtocolRefs.push_back(ProtoInExtension); 215 } 216 217 if (ProtocolRefs.empty()) 218 return; 219 220 // Merge ProtocolRefs into class's protocol list; 221 for (all_protocol_iterator p = all_referenced_protocol_begin(), 222 e = all_referenced_protocol_end(); p != e; ++p) { 223 ProtocolRefs.push_back(*p); 224 } 225 226 data().AllReferencedProtocols.set(ProtocolRefs.data(), ProtocolRefs.size(),C); 227 } 228 229 void ObjCInterfaceDecl::allocateDefinitionData() { 230 assert(!hasDefinition() && "ObjC class already has a definition"); 231 Data = new (getASTContext()) DefinitionData(); 232 Data->Definition = this; 233 234 // Make the type point at the definition, now that we have one. 235 if (TypeForDecl) 236 cast<ObjCInterfaceType>(TypeForDecl)->Decl = this; 237 } 238 239 void ObjCInterfaceDecl::startDefinition() { 240 allocateDefinitionData(); 241 242 // Update all of the declarations with a pointer to the definition. 243 for (redecl_iterator RD = redecls_begin(), RDEnd = redecls_end(); 244 RD != RDEnd; ++RD) { 245 if (*RD != this) 246 RD->Data = Data; 247 } 248 } 249 250 /// getFirstClassExtension - Find first class extension of the given class. 251 ObjCCategoryDecl* ObjCInterfaceDecl::getFirstClassExtension() const { 252 for (ObjCCategoryDecl *CDecl = getCategoryList(); CDecl; 253 CDecl = CDecl->getNextClassCategory()) 254 if (CDecl->IsClassExtension()) 255 return CDecl; 256 return 0; 257 } 258 259 /// getNextClassCategory - Find next class extension in list of categories. 260 const ObjCCategoryDecl* ObjCCategoryDecl::getNextClassExtension() const { 261 for (const ObjCCategoryDecl *CDecl = getNextClassCategory(); CDecl; 262 CDecl = CDecl->getNextClassCategory()) 263 if (CDecl->IsClassExtension()) 264 return CDecl; 265 return 0; 266 } 267 268 ObjCIvarDecl *ObjCInterfaceDecl::lookupInstanceVariable(IdentifierInfo *ID, 269 ObjCInterfaceDecl *&clsDeclared) { 270 // FIXME: Should make sure no callers ever do this. 271 if (!hasDefinition()) 272 return 0; 273 274 if (data().ExternallyCompleted) 275 LoadExternalDefinition(); 276 277 ObjCInterfaceDecl* ClassDecl = this; 278 while (ClassDecl != NULL) { 279 if (ObjCIvarDecl *I = ClassDecl->getIvarDecl(ID)) { 280 clsDeclared = ClassDecl; 281 return I; 282 } 283 for (const ObjCCategoryDecl *CDecl = ClassDecl->getFirstClassExtension(); 284 CDecl; CDecl = CDecl->getNextClassExtension()) { 285 if (ObjCIvarDecl *I = CDecl->getIvarDecl(ID)) { 286 clsDeclared = ClassDecl; 287 return I; 288 } 289 } 290 291 ClassDecl = ClassDecl->getSuperClass(); 292 } 293 return NULL; 294 } 295 296 /// lookupInheritedClass - This method returns ObjCInterfaceDecl * of the super 297 /// class whose name is passed as argument. If it is not one of the super classes 298 /// the it returns NULL. 299 ObjCInterfaceDecl *ObjCInterfaceDecl::lookupInheritedClass( 300 const IdentifierInfo*ICName) { 301 // FIXME: Should make sure no callers ever do this. 302 if (!hasDefinition()) 303 return 0; 304 305 if (data().ExternallyCompleted) 306 LoadExternalDefinition(); 307 308 ObjCInterfaceDecl* ClassDecl = this; 309 while (ClassDecl != NULL) { 310 if (ClassDecl->getIdentifier() == ICName) 311 return ClassDecl; 312 ClassDecl = ClassDecl->getSuperClass(); 313 } 314 return NULL; 315 } 316 317 /// lookupMethod - This method returns an instance/class method by looking in 318 /// the class, its categories, and its super classes (using a linear search). 319 ObjCMethodDecl *ObjCInterfaceDecl::lookupMethod(Selector Sel, 320 bool isInstance, 321 bool shallowCategoryLookup) const { 322 // FIXME: Should make sure no callers ever do this. 323 if (!hasDefinition()) 324 return 0; 325 326 const ObjCInterfaceDecl* ClassDecl = this; 327 ObjCMethodDecl *MethodDecl = 0; 328 329 if (data().ExternallyCompleted) 330 LoadExternalDefinition(); 331 332 while (ClassDecl != NULL) { 333 if ((MethodDecl = ClassDecl->getMethod(Sel, isInstance))) 334 return MethodDecl; 335 336 // Didn't find one yet - look through protocols. 337 for (ObjCInterfaceDecl::protocol_iterator I = ClassDecl->protocol_begin(), 338 E = ClassDecl->protocol_end(); 339 I != E; ++I) 340 if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance))) 341 return MethodDecl; 342 343 // Didn't find one yet - now look through categories. 344 ObjCCategoryDecl *CatDecl = ClassDecl->getCategoryList(); 345 while (CatDecl) { 346 if ((MethodDecl = CatDecl->getMethod(Sel, isInstance))) 347 return MethodDecl; 348 349 if (!shallowCategoryLookup) { 350 // Didn't find one yet - look through protocols. 351 const ObjCList<ObjCProtocolDecl> &Protocols = 352 CatDecl->getReferencedProtocols(); 353 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 354 E = Protocols.end(); I != E; ++I) 355 if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance))) 356 return MethodDecl; 357 } 358 CatDecl = CatDecl->getNextClassCategory(); 359 } 360 361 ClassDecl = ClassDecl->getSuperClass(); 362 } 363 return NULL; 364 } 365 366 // Will search "local" class/category implementations for a method decl. 367 // If failed, then we search in class's root for an instance method. 368 // Returns 0 if no method is found. 369 ObjCMethodDecl *ObjCInterfaceDecl::lookupPrivateMethod( 370 const Selector &Sel, 371 bool Instance) const { 372 // FIXME: Should make sure no callers ever do this. 373 if (!hasDefinition()) 374 return 0; 375 376 if (data().ExternallyCompleted) 377 LoadExternalDefinition(); 378 379 ObjCMethodDecl *Method = 0; 380 if (ObjCImplementationDecl *ImpDecl = getImplementation()) 381 Method = Instance ? ImpDecl->getInstanceMethod(Sel) 382 : ImpDecl->getClassMethod(Sel); 383 384 // Look through local category implementations associated with the class. 385 if (!Method) 386 Method = Instance ? getCategoryInstanceMethod(Sel) 387 : getCategoryClassMethod(Sel); 388 389 // Before we give up, check if the selector is an instance method. 390 // But only in the root. This matches gcc's behavior and what the 391 // runtime expects. 392 if (!Instance && !Method && !getSuperClass()) { 393 Method = lookupInstanceMethod(Sel); 394 // Look through local category implementations associated 395 // with the root class. 396 if (!Method) 397 Method = lookupPrivateMethod(Sel, true); 398 } 399 400 if (!Method && getSuperClass()) 401 return getSuperClass()->lookupPrivateMethod(Sel, Instance); 402 return Method; 403 } 404 405 //===----------------------------------------------------------------------===// 406 // ObjCMethodDecl 407 //===----------------------------------------------------------------------===// 408 409 ObjCMethodDecl *ObjCMethodDecl::Create(ASTContext &C, 410 SourceLocation beginLoc, 411 SourceLocation endLoc, 412 Selector SelInfo, QualType T, 413 TypeSourceInfo *ResultTInfo, 414 DeclContext *contextDecl, 415 bool isInstance, 416 bool isVariadic, 417 bool isSynthesized, 418 bool isImplicitlyDeclared, 419 bool isDefined, 420 ImplementationControl impControl, 421 bool HasRelatedResultType) { 422 return new (C) ObjCMethodDecl(beginLoc, endLoc, 423 SelInfo, T, ResultTInfo, contextDecl, 424 isInstance, 425 isVariadic, isSynthesized, isImplicitlyDeclared, 426 isDefined, 427 impControl, 428 HasRelatedResultType); 429 } 430 431 ObjCMethodDecl *ObjCMethodDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 432 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCMethodDecl)); 433 return new (Mem) ObjCMethodDecl(SourceLocation(), SourceLocation(), 434 Selector(), QualType(), 0, 0); 435 } 436 437 void ObjCMethodDecl::setAsRedeclaration(const ObjCMethodDecl *PrevMethod) { 438 assert(PrevMethod); 439 getASTContext().setObjCMethodRedeclaration(PrevMethod, this); 440 IsRedeclaration = true; 441 PrevMethod->HasRedeclaration = true; 442 } 443 444 void ObjCMethodDecl::setParamsAndSelLocs(ASTContext &C, 445 ArrayRef<ParmVarDecl*> Params, 446 ArrayRef<SourceLocation> SelLocs) { 447 ParamsAndSelLocs = 0; 448 NumParams = Params.size(); 449 if (Params.empty() && SelLocs.empty()) 450 return; 451 452 unsigned Size = sizeof(ParmVarDecl *) * NumParams + 453 sizeof(SourceLocation) * SelLocs.size(); 454 ParamsAndSelLocs = C.Allocate(Size); 455 std::copy(Params.begin(), Params.end(), getParams()); 456 std::copy(SelLocs.begin(), SelLocs.end(), getStoredSelLocs()); 457 } 458 459 void ObjCMethodDecl::getSelectorLocs( 460 SmallVectorImpl<SourceLocation> &SelLocs) const { 461 for (unsigned i = 0, e = getNumSelectorLocs(); i != e; ++i) 462 SelLocs.push_back(getSelectorLoc(i)); 463 } 464 465 void ObjCMethodDecl::setMethodParams(ASTContext &C, 466 ArrayRef<ParmVarDecl*> Params, 467 ArrayRef<SourceLocation> SelLocs) { 468 assert((!SelLocs.empty() || isImplicit()) && 469 "No selector locs for non-implicit method"); 470 if (isImplicit()) 471 return setParamsAndSelLocs(C, Params, ArrayRef<SourceLocation>()); 472 473 SelLocsKind = hasStandardSelectorLocs(getSelector(), SelLocs, Params, 474 DeclEndLoc); 475 if (SelLocsKind != SelLoc_NonStandard) 476 return setParamsAndSelLocs(C, Params, ArrayRef<SourceLocation>()); 477 478 setParamsAndSelLocs(C, Params, SelLocs); 479 } 480 481 /// \brief A definition will return its interface declaration. 482 /// An interface declaration will return its definition. 483 /// Otherwise it will return itself. 484 ObjCMethodDecl *ObjCMethodDecl::getNextRedeclaration() { 485 ASTContext &Ctx = getASTContext(); 486 ObjCMethodDecl *Redecl = 0; 487 if (HasRedeclaration) 488 Redecl = const_cast<ObjCMethodDecl*>(Ctx.getObjCMethodRedeclaration(this)); 489 if (Redecl) 490 return Redecl; 491 492 Decl *CtxD = cast<Decl>(getDeclContext()); 493 494 if (ObjCInterfaceDecl *IFD = dyn_cast<ObjCInterfaceDecl>(CtxD)) { 495 if (ObjCImplementationDecl *ImplD = Ctx.getObjCImplementation(IFD)) 496 Redecl = ImplD->getMethod(getSelector(), isInstanceMethod()); 497 498 } else if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CtxD)) { 499 if (ObjCCategoryImplDecl *ImplD = Ctx.getObjCImplementation(CD)) 500 Redecl = ImplD->getMethod(getSelector(), isInstanceMethod()); 501 502 } else if (ObjCImplementationDecl *ImplD = 503 dyn_cast<ObjCImplementationDecl>(CtxD)) { 504 if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface()) 505 Redecl = IFD->getMethod(getSelector(), isInstanceMethod()); 506 507 } else if (ObjCCategoryImplDecl *CImplD = 508 dyn_cast<ObjCCategoryImplDecl>(CtxD)) { 509 if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl()) 510 Redecl = CatD->getMethod(getSelector(), isInstanceMethod()); 511 } 512 513 if (!Redecl && isRedeclaration()) { 514 // This is the last redeclaration, go back to the first method. 515 return cast<ObjCContainerDecl>(CtxD)->getMethod(getSelector(), 516 isInstanceMethod()); 517 } 518 519 return Redecl ? Redecl : this; 520 } 521 522 ObjCMethodDecl *ObjCMethodDecl::getCanonicalDecl() { 523 Decl *CtxD = cast<Decl>(getDeclContext()); 524 525 if (ObjCImplementationDecl *ImplD = dyn_cast<ObjCImplementationDecl>(CtxD)) { 526 if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface()) 527 if (ObjCMethodDecl *MD = IFD->getMethod(getSelector(), 528 isInstanceMethod())) 529 return MD; 530 531 } else if (ObjCCategoryImplDecl *CImplD = 532 dyn_cast<ObjCCategoryImplDecl>(CtxD)) { 533 if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl()) 534 if (ObjCMethodDecl *MD = CatD->getMethod(getSelector(), 535 isInstanceMethod())) 536 return MD; 537 } 538 539 if (isRedeclaration()) 540 return cast<ObjCContainerDecl>(CtxD)->getMethod(getSelector(), 541 isInstanceMethod()); 542 543 return this; 544 } 545 546 SourceLocation ObjCMethodDecl::getLocEnd() const { 547 if (Stmt *Body = getBody()) 548 return Body->getLocEnd(); 549 return DeclEndLoc; 550 } 551 552 ObjCMethodFamily ObjCMethodDecl::getMethodFamily() const { 553 ObjCMethodFamily family = static_cast<ObjCMethodFamily>(Family); 554 if (family != static_cast<unsigned>(InvalidObjCMethodFamily)) 555 return family; 556 557 // Check for an explicit attribute. 558 if (const ObjCMethodFamilyAttr *attr = getAttr<ObjCMethodFamilyAttr>()) { 559 // The unfortunate necessity of mapping between enums here is due 560 // to the attributes framework. 561 switch (attr->getFamily()) { 562 case ObjCMethodFamilyAttr::OMF_None: family = OMF_None; break; 563 case ObjCMethodFamilyAttr::OMF_alloc: family = OMF_alloc; break; 564 case ObjCMethodFamilyAttr::OMF_copy: family = OMF_copy; break; 565 case ObjCMethodFamilyAttr::OMF_init: family = OMF_init; break; 566 case ObjCMethodFamilyAttr::OMF_mutableCopy: family = OMF_mutableCopy; break; 567 case ObjCMethodFamilyAttr::OMF_new: family = OMF_new; break; 568 } 569 Family = static_cast<unsigned>(family); 570 return family; 571 } 572 573 family = getSelector().getMethodFamily(); 574 switch (family) { 575 case OMF_None: break; 576 577 // init only has a conventional meaning for an instance method, and 578 // it has to return an object. 579 case OMF_init: 580 if (!isInstanceMethod() || !getResultType()->isObjCObjectPointerType()) 581 family = OMF_None; 582 break; 583 584 // alloc/copy/new have a conventional meaning for both class and 585 // instance methods, but they require an object return. 586 case OMF_alloc: 587 case OMF_copy: 588 case OMF_mutableCopy: 589 case OMF_new: 590 if (!getResultType()->isObjCObjectPointerType()) 591 family = OMF_None; 592 break; 593 594 // These selectors have a conventional meaning only for instance methods. 595 case OMF_dealloc: 596 case OMF_finalize: 597 case OMF_retain: 598 case OMF_release: 599 case OMF_autorelease: 600 case OMF_retainCount: 601 case OMF_self: 602 if (!isInstanceMethod()) 603 family = OMF_None; 604 break; 605 606 case OMF_performSelector: 607 if (!isInstanceMethod() || 608 !getResultType()->isObjCIdType()) 609 family = OMF_None; 610 else { 611 unsigned noParams = param_size(); 612 if (noParams < 1 || noParams > 3) 613 family = OMF_None; 614 else { 615 ObjCMethodDecl::arg_type_iterator it = arg_type_begin(); 616 QualType ArgT = (*it); 617 if (!ArgT->isObjCSelType()) { 618 family = OMF_None; 619 break; 620 } 621 while (--noParams) { 622 it++; 623 ArgT = (*it); 624 if (!ArgT->isObjCIdType()) { 625 family = OMF_None; 626 break; 627 } 628 } 629 } 630 } 631 break; 632 633 } 634 635 // Cache the result. 636 Family = static_cast<unsigned>(family); 637 return family; 638 } 639 640 void ObjCMethodDecl::createImplicitParams(ASTContext &Context, 641 const ObjCInterfaceDecl *OID) { 642 QualType selfTy; 643 if (isInstanceMethod()) { 644 // There may be no interface context due to error in declaration 645 // of the interface (which has been reported). Recover gracefully. 646 if (OID) { 647 selfTy = Context.getObjCInterfaceType(OID); 648 selfTy = Context.getObjCObjectPointerType(selfTy); 649 } else { 650 selfTy = Context.getObjCIdType(); 651 } 652 } else // we have a factory method. 653 selfTy = Context.getObjCClassType(); 654 655 bool selfIsPseudoStrong = false; 656 bool selfIsConsumed = false; 657 658 if (Context.getLangOpts().ObjCAutoRefCount) { 659 if (isInstanceMethod()) { 660 selfIsConsumed = hasAttr<NSConsumesSelfAttr>(); 661 662 // 'self' is always __strong. It's actually pseudo-strong except 663 // in init methods (or methods labeled ns_consumes_self), though. 664 Qualifiers qs; 665 qs.setObjCLifetime(Qualifiers::OCL_Strong); 666 selfTy = Context.getQualifiedType(selfTy, qs); 667 668 // In addition, 'self' is const unless this is an init method. 669 if (getMethodFamily() != OMF_init && !selfIsConsumed) { 670 selfTy = selfTy.withConst(); 671 selfIsPseudoStrong = true; 672 } 673 } 674 else { 675 assert(isClassMethod()); 676 // 'self' is always const in class methods. 677 selfTy = selfTy.withConst(); 678 selfIsPseudoStrong = true; 679 } 680 } 681 682 ImplicitParamDecl *self 683 = ImplicitParamDecl::Create(Context, this, SourceLocation(), 684 &Context.Idents.get("self"), selfTy); 685 setSelfDecl(self); 686 687 if (selfIsConsumed) 688 self->addAttr(new (Context) NSConsumedAttr(SourceLocation(), Context)); 689 690 if (selfIsPseudoStrong) 691 self->setARCPseudoStrong(true); 692 693 setCmdDecl(ImplicitParamDecl::Create(Context, this, SourceLocation(), 694 &Context.Idents.get("_cmd"), 695 Context.getObjCSelType())); 696 } 697 698 ObjCInterfaceDecl *ObjCMethodDecl::getClassInterface() { 699 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(getDeclContext())) 700 return ID; 701 if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(getDeclContext())) 702 return CD->getClassInterface(); 703 if (ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(getDeclContext())) 704 return IMD->getClassInterface(); 705 706 assert(!isa<ObjCProtocolDecl>(getDeclContext()) && "It's a protocol method"); 707 llvm_unreachable("unknown method context"); 708 } 709 710 //===----------------------------------------------------------------------===// 711 // ObjCInterfaceDecl 712 //===----------------------------------------------------------------------===// 713 714 ObjCInterfaceDecl *ObjCInterfaceDecl::Create(const ASTContext &C, 715 DeclContext *DC, 716 SourceLocation atLoc, 717 IdentifierInfo *Id, 718 ObjCInterfaceDecl *PrevDecl, 719 SourceLocation ClassLoc, 720 bool isInternal){ 721 ObjCInterfaceDecl *Result = new (C) ObjCInterfaceDecl(DC, atLoc, Id, ClassLoc, 722 PrevDecl, isInternal); 723 C.getObjCInterfaceType(Result, PrevDecl); 724 return Result; 725 } 726 727 ObjCInterfaceDecl *ObjCInterfaceDecl::CreateDeserialized(ASTContext &C, 728 unsigned ID) { 729 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCInterfaceDecl)); 730 return new (Mem) ObjCInterfaceDecl(0, SourceLocation(), 0, SourceLocation(), 731 0, false); 732 } 733 734 ObjCInterfaceDecl:: 735 ObjCInterfaceDecl(DeclContext *DC, SourceLocation atLoc, IdentifierInfo *Id, 736 SourceLocation CLoc, ObjCInterfaceDecl *PrevDecl, 737 bool isInternal) 738 : ObjCContainerDecl(ObjCInterface, DC, Id, CLoc, atLoc), 739 TypeForDecl(0), Data() 740 { 741 setPreviousDeclaration(PrevDecl); 742 743 // Copy the 'data' pointer over. 744 if (PrevDecl) 745 Data = PrevDecl->Data; 746 747 setImplicit(isInternal); 748 } 749 750 void ObjCInterfaceDecl::LoadExternalDefinition() const { 751 assert(data().ExternallyCompleted && "Class is not externally completed"); 752 data().ExternallyCompleted = false; 753 getASTContext().getExternalSource()->CompleteType( 754 const_cast<ObjCInterfaceDecl *>(this)); 755 } 756 757 void ObjCInterfaceDecl::setExternallyCompleted() { 758 assert(getASTContext().getExternalSource() && 759 "Class can't be externally completed without an external source"); 760 assert(hasDefinition() && 761 "Forward declarations can't be externally completed"); 762 data().ExternallyCompleted = true; 763 } 764 765 ObjCImplementationDecl *ObjCInterfaceDecl::getImplementation() const { 766 if (const ObjCInterfaceDecl *Def = getDefinition()) { 767 if (data().ExternallyCompleted) 768 LoadExternalDefinition(); 769 770 return getASTContext().getObjCImplementation( 771 const_cast<ObjCInterfaceDecl*>(Def)); 772 } 773 774 // FIXME: Should make sure no callers ever do this. 775 return 0; 776 } 777 778 void ObjCInterfaceDecl::setImplementation(ObjCImplementationDecl *ImplD) { 779 getASTContext().setObjCImplementation(getDefinition(), ImplD); 780 } 781 782 /// all_declared_ivar_begin - return first ivar declared in this class, 783 /// its extensions and its implementation. Lazily build the list on first 784 /// access. 785 ObjCIvarDecl *ObjCInterfaceDecl::all_declared_ivar_begin() { 786 // FIXME: Should make sure no callers ever do this. 787 if (!hasDefinition()) 788 return 0; 789 790 if (data().IvarList) 791 return data().IvarList; 792 793 ObjCIvarDecl *curIvar = 0; 794 if (!ivar_empty()) { 795 ObjCInterfaceDecl::ivar_iterator I = ivar_begin(), E = ivar_end(); 796 data().IvarList = *I; ++I; 797 for (curIvar = data().IvarList; I != E; curIvar = *I, ++I) 798 curIvar->setNextIvar(*I); 799 } 800 801 for (const ObjCCategoryDecl *CDecl = getFirstClassExtension(); CDecl; 802 CDecl = CDecl->getNextClassExtension()) { 803 if (!CDecl->ivar_empty()) { 804 ObjCCategoryDecl::ivar_iterator I = CDecl->ivar_begin(), 805 E = CDecl->ivar_end(); 806 if (!data().IvarList) { 807 data().IvarList = *I; ++I; 808 curIvar = data().IvarList; 809 } 810 for ( ;I != E; curIvar = *I, ++I) 811 curIvar->setNextIvar(*I); 812 } 813 } 814 815 if (ObjCImplementationDecl *ImplDecl = getImplementation()) { 816 if (!ImplDecl->ivar_empty()) { 817 ObjCImplementationDecl::ivar_iterator I = ImplDecl->ivar_begin(), 818 E = ImplDecl->ivar_end(); 819 if (!data().IvarList) { 820 data().IvarList = *I; ++I; 821 curIvar = data().IvarList; 822 } 823 for ( ;I != E; curIvar = *I, ++I) 824 curIvar->setNextIvar(*I); 825 } 826 } 827 return data().IvarList; 828 } 829 830 /// FindCategoryDeclaration - Finds category declaration in the list of 831 /// categories for this class and returns it. Name of the category is passed 832 /// in 'CategoryId'. If category not found, return 0; 833 /// 834 ObjCCategoryDecl * 835 ObjCInterfaceDecl::FindCategoryDeclaration(IdentifierInfo *CategoryId) const { 836 // FIXME: Should make sure no callers ever do this. 837 if (!hasDefinition()) 838 return 0; 839 840 if (data().ExternallyCompleted) 841 LoadExternalDefinition(); 842 843 for (ObjCCategoryDecl *Category = getCategoryList(); 844 Category; Category = Category->getNextClassCategory()) 845 if (Category->getIdentifier() == CategoryId) 846 return Category; 847 return 0; 848 } 849 850 ObjCMethodDecl * 851 ObjCInterfaceDecl::getCategoryInstanceMethod(Selector Sel) const { 852 for (ObjCCategoryDecl *Category = getCategoryList(); 853 Category; Category = Category->getNextClassCategory()) 854 if (ObjCCategoryImplDecl *Impl = Category->getImplementation()) 855 if (ObjCMethodDecl *MD = Impl->getInstanceMethod(Sel)) 856 return MD; 857 return 0; 858 } 859 860 ObjCMethodDecl *ObjCInterfaceDecl::getCategoryClassMethod(Selector Sel) const { 861 for (ObjCCategoryDecl *Category = getCategoryList(); 862 Category; Category = Category->getNextClassCategory()) 863 if (ObjCCategoryImplDecl *Impl = Category->getImplementation()) 864 if (ObjCMethodDecl *MD = Impl->getClassMethod(Sel)) 865 return MD; 866 return 0; 867 } 868 869 /// ClassImplementsProtocol - Checks that 'lProto' protocol 870 /// has been implemented in IDecl class, its super class or categories (if 871 /// lookupCategory is true). 872 bool ObjCInterfaceDecl::ClassImplementsProtocol(ObjCProtocolDecl *lProto, 873 bool lookupCategory, 874 bool RHSIsQualifiedID) { 875 if (!hasDefinition()) 876 return false; 877 878 ObjCInterfaceDecl *IDecl = this; 879 // 1st, look up the class. 880 for (ObjCInterfaceDecl::protocol_iterator 881 PI = IDecl->protocol_begin(), E = IDecl->protocol_end(); PI != E; ++PI){ 882 if (getASTContext().ProtocolCompatibleWithProtocol(lProto, *PI)) 883 return true; 884 // This is dubious and is added to be compatible with gcc. In gcc, it is 885 // also allowed assigning a protocol-qualified 'id' type to a LHS object 886 // when protocol in qualified LHS is in list of protocols in the rhs 'id' 887 // object. This IMO, should be a bug. 888 // FIXME: Treat this as an extension, and flag this as an error when GCC 889 // extensions are not enabled. 890 if (RHSIsQualifiedID && 891 getASTContext().ProtocolCompatibleWithProtocol(*PI, lProto)) 892 return true; 893 } 894 895 // 2nd, look up the category. 896 if (lookupCategory) 897 for (ObjCCategoryDecl *CDecl = IDecl->getCategoryList(); CDecl; 898 CDecl = CDecl->getNextClassCategory()) { 899 for (ObjCCategoryDecl::protocol_iterator PI = CDecl->protocol_begin(), 900 E = CDecl->protocol_end(); PI != E; ++PI) 901 if (getASTContext().ProtocolCompatibleWithProtocol(lProto, *PI)) 902 return true; 903 } 904 905 // 3rd, look up the super class(s) 906 if (IDecl->getSuperClass()) 907 return 908 IDecl->getSuperClass()->ClassImplementsProtocol(lProto, lookupCategory, 909 RHSIsQualifiedID); 910 911 return false; 912 } 913 914 //===----------------------------------------------------------------------===// 915 // ObjCIvarDecl 916 //===----------------------------------------------------------------------===// 917 918 void ObjCIvarDecl::anchor() { } 919 920 ObjCIvarDecl *ObjCIvarDecl::Create(ASTContext &C, ObjCContainerDecl *DC, 921 SourceLocation StartLoc, 922 SourceLocation IdLoc, IdentifierInfo *Id, 923 QualType T, TypeSourceInfo *TInfo, 924 AccessControl ac, Expr *BW, 925 bool synthesized) { 926 if (DC) { 927 // Ivar's can only appear in interfaces, implementations (via synthesized 928 // properties), and class extensions (via direct declaration, or synthesized 929 // properties). 930 // 931 // FIXME: This should really be asserting this: 932 // (isa<ObjCCategoryDecl>(DC) && 933 // cast<ObjCCategoryDecl>(DC)->IsClassExtension())) 934 // but unfortunately we sometimes place ivars into non-class extension 935 // categories on error. This breaks an AST invariant, and should not be 936 // fixed. 937 assert((isa<ObjCInterfaceDecl>(DC) || isa<ObjCImplementationDecl>(DC) || 938 isa<ObjCCategoryDecl>(DC)) && 939 "Invalid ivar decl context!"); 940 // Once a new ivar is created in any of class/class-extension/implementation 941 // decl contexts, the previously built IvarList must be rebuilt. 942 ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(DC); 943 if (!ID) { 944 if (ObjCImplementationDecl *IM = dyn_cast<ObjCImplementationDecl>(DC)) 945 ID = IM->getClassInterface(); 946 else 947 ID = cast<ObjCCategoryDecl>(DC)->getClassInterface(); 948 } 949 ID->setIvarList(0); 950 } 951 952 return new (C) ObjCIvarDecl(DC, StartLoc, IdLoc, Id, T, TInfo, 953 ac, BW, synthesized); 954 } 955 956 ObjCIvarDecl *ObjCIvarDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 957 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCIvarDecl)); 958 return new (Mem) ObjCIvarDecl(0, SourceLocation(), SourceLocation(), 0, 959 QualType(), 0, ObjCIvarDecl::None, 0, false); 960 } 961 962 const ObjCInterfaceDecl *ObjCIvarDecl::getContainingInterface() const { 963 const ObjCContainerDecl *DC = cast<ObjCContainerDecl>(getDeclContext()); 964 965 switch (DC->getKind()) { 966 default: 967 case ObjCCategoryImpl: 968 case ObjCProtocol: 969 llvm_unreachable("invalid ivar container!"); 970 971 // Ivars can only appear in class extension categories. 972 case ObjCCategory: { 973 const ObjCCategoryDecl *CD = cast<ObjCCategoryDecl>(DC); 974 assert(CD->IsClassExtension() && "invalid container for ivar!"); 975 return CD->getClassInterface(); 976 } 977 978 case ObjCImplementation: 979 return cast<ObjCImplementationDecl>(DC)->getClassInterface(); 980 981 case ObjCInterface: 982 return cast<ObjCInterfaceDecl>(DC); 983 } 984 } 985 986 //===----------------------------------------------------------------------===// 987 // ObjCAtDefsFieldDecl 988 //===----------------------------------------------------------------------===// 989 990 void ObjCAtDefsFieldDecl::anchor() { } 991 992 ObjCAtDefsFieldDecl 993 *ObjCAtDefsFieldDecl::Create(ASTContext &C, DeclContext *DC, 994 SourceLocation StartLoc, SourceLocation IdLoc, 995 IdentifierInfo *Id, QualType T, Expr *BW) { 996 return new (C) ObjCAtDefsFieldDecl(DC, StartLoc, IdLoc, Id, T, BW); 997 } 998 999 ObjCAtDefsFieldDecl *ObjCAtDefsFieldDecl::CreateDeserialized(ASTContext &C, 1000 unsigned ID) { 1001 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCAtDefsFieldDecl)); 1002 return new (Mem) ObjCAtDefsFieldDecl(0, SourceLocation(), SourceLocation(), 1003 0, QualType(), 0); 1004 } 1005 1006 //===----------------------------------------------------------------------===// 1007 // ObjCProtocolDecl 1008 //===----------------------------------------------------------------------===// 1009 1010 void ObjCProtocolDecl::anchor() { } 1011 1012 ObjCProtocolDecl::ObjCProtocolDecl(DeclContext *DC, IdentifierInfo *Id, 1013 SourceLocation nameLoc, 1014 SourceLocation atStartLoc, 1015 ObjCProtocolDecl *PrevDecl) 1016 : ObjCContainerDecl(ObjCProtocol, DC, Id, nameLoc, atStartLoc), Data() 1017 { 1018 setPreviousDeclaration(PrevDecl); 1019 if (PrevDecl) 1020 Data = PrevDecl->Data; 1021 } 1022 1023 ObjCProtocolDecl *ObjCProtocolDecl::Create(ASTContext &C, DeclContext *DC, 1024 IdentifierInfo *Id, 1025 SourceLocation nameLoc, 1026 SourceLocation atStartLoc, 1027 ObjCProtocolDecl *PrevDecl) { 1028 ObjCProtocolDecl *Result 1029 = new (C) ObjCProtocolDecl(DC, Id, nameLoc, atStartLoc, PrevDecl); 1030 1031 return Result; 1032 } 1033 1034 ObjCProtocolDecl *ObjCProtocolDecl::CreateDeserialized(ASTContext &C, 1035 unsigned ID) { 1036 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCProtocolDecl)); 1037 return new (Mem) ObjCProtocolDecl(0, 0, SourceLocation(), SourceLocation(), 1038 0); 1039 } 1040 1041 ObjCProtocolDecl *ObjCProtocolDecl::lookupProtocolNamed(IdentifierInfo *Name) { 1042 ObjCProtocolDecl *PDecl = this; 1043 1044 if (Name == getIdentifier()) 1045 return PDecl; 1046 1047 for (protocol_iterator I = protocol_begin(), E = protocol_end(); I != E; ++I) 1048 if ((PDecl = (*I)->lookupProtocolNamed(Name))) 1049 return PDecl; 1050 1051 return NULL; 1052 } 1053 1054 // lookupMethod - Lookup a instance/class method in the protocol and protocols 1055 // it inherited. 1056 ObjCMethodDecl *ObjCProtocolDecl::lookupMethod(Selector Sel, 1057 bool isInstance) const { 1058 ObjCMethodDecl *MethodDecl = NULL; 1059 1060 if ((MethodDecl = getMethod(Sel, isInstance))) 1061 return MethodDecl; 1062 1063 for (protocol_iterator I = protocol_begin(), E = protocol_end(); I != E; ++I) 1064 if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance))) 1065 return MethodDecl; 1066 return NULL; 1067 } 1068 1069 void ObjCProtocolDecl::allocateDefinitionData() { 1070 assert(!Data && "Protocol already has a definition!"); 1071 Data = new (getASTContext()) DefinitionData; 1072 Data->Definition = this; 1073 } 1074 1075 void ObjCProtocolDecl::startDefinition() { 1076 allocateDefinitionData(); 1077 1078 // Update all of the declarations with a pointer to the definition. 1079 for (redecl_iterator RD = redecls_begin(), RDEnd = redecls_end(); 1080 RD != RDEnd; ++RD) 1081 RD->Data = this->Data; 1082 } 1083 1084 //===----------------------------------------------------------------------===// 1085 // ObjCCategoryDecl 1086 //===----------------------------------------------------------------------===// 1087 1088 void ObjCCategoryDecl::anchor() { } 1089 1090 ObjCCategoryDecl *ObjCCategoryDecl::Create(ASTContext &C, DeclContext *DC, 1091 SourceLocation AtLoc, 1092 SourceLocation ClassNameLoc, 1093 SourceLocation CategoryNameLoc, 1094 IdentifierInfo *Id, 1095 ObjCInterfaceDecl *IDecl, 1096 SourceLocation IvarLBraceLoc, 1097 SourceLocation IvarRBraceLoc) { 1098 ObjCCategoryDecl *CatDecl = new (C) ObjCCategoryDecl(DC, AtLoc, ClassNameLoc, 1099 CategoryNameLoc, Id, 1100 IDecl, 1101 IvarLBraceLoc, IvarRBraceLoc); 1102 if (IDecl) { 1103 // Link this category into its class's category list. 1104 CatDecl->NextClassCategory = IDecl->getCategoryList(); 1105 if (IDecl->hasDefinition()) { 1106 IDecl->setCategoryList(CatDecl); 1107 if (ASTMutationListener *L = C.getASTMutationListener()) 1108 L->AddedObjCCategoryToInterface(CatDecl, IDecl); 1109 } 1110 } 1111 1112 return CatDecl; 1113 } 1114 1115 ObjCCategoryDecl *ObjCCategoryDecl::CreateDeserialized(ASTContext &C, 1116 unsigned ID) { 1117 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCCategoryDecl)); 1118 return new (Mem) ObjCCategoryDecl(0, SourceLocation(), SourceLocation(), 1119 SourceLocation(), 0, 0); 1120 } 1121 1122 ObjCCategoryImplDecl *ObjCCategoryDecl::getImplementation() const { 1123 return getASTContext().getObjCImplementation( 1124 const_cast<ObjCCategoryDecl*>(this)); 1125 } 1126 1127 void ObjCCategoryDecl::setImplementation(ObjCCategoryImplDecl *ImplD) { 1128 getASTContext().setObjCImplementation(this, ImplD); 1129 } 1130 1131 1132 //===----------------------------------------------------------------------===// 1133 // ObjCCategoryImplDecl 1134 //===----------------------------------------------------------------------===// 1135 1136 void ObjCCategoryImplDecl::anchor() { } 1137 1138 ObjCCategoryImplDecl * 1139 ObjCCategoryImplDecl::Create(ASTContext &C, DeclContext *DC, 1140 IdentifierInfo *Id, 1141 ObjCInterfaceDecl *ClassInterface, 1142 SourceLocation nameLoc, 1143 SourceLocation atStartLoc, 1144 SourceLocation CategoryNameLoc) { 1145 if (ClassInterface && ClassInterface->hasDefinition()) 1146 ClassInterface = ClassInterface->getDefinition(); 1147 return new (C) ObjCCategoryImplDecl(DC, Id, ClassInterface, 1148 nameLoc, atStartLoc, CategoryNameLoc); 1149 } 1150 1151 ObjCCategoryImplDecl *ObjCCategoryImplDecl::CreateDeserialized(ASTContext &C, 1152 unsigned ID) { 1153 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCCategoryImplDecl)); 1154 return new (Mem) ObjCCategoryImplDecl(0, 0, 0, SourceLocation(), 1155 SourceLocation(), SourceLocation()); 1156 } 1157 1158 ObjCCategoryDecl *ObjCCategoryImplDecl::getCategoryDecl() const { 1159 // The class interface might be NULL if we are working with invalid code. 1160 if (const ObjCInterfaceDecl *ID = getClassInterface()) 1161 return ID->FindCategoryDeclaration(getIdentifier()); 1162 return 0; 1163 } 1164 1165 1166 void ObjCImplDecl::anchor() { } 1167 1168 void ObjCImplDecl::addPropertyImplementation(ObjCPropertyImplDecl *property) { 1169 // FIXME: The context should be correct before we get here. 1170 property->setLexicalDeclContext(this); 1171 addDecl(property); 1172 } 1173 1174 void ObjCImplDecl::setClassInterface(ObjCInterfaceDecl *IFace) { 1175 ASTContext &Ctx = getASTContext(); 1176 1177 if (ObjCImplementationDecl *ImplD 1178 = dyn_cast_or_null<ObjCImplementationDecl>(this)) { 1179 if (IFace) 1180 Ctx.setObjCImplementation(IFace, ImplD); 1181 1182 } else if (ObjCCategoryImplDecl *ImplD = 1183 dyn_cast_or_null<ObjCCategoryImplDecl>(this)) { 1184 if (ObjCCategoryDecl *CD = IFace->FindCategoryDeclaration(getIdentifier())) 1185 Ctx.setObjCImplementation(CD, ImplD); 1186 } 1187 1188 ClassInterface = IFace; 1189 } 1190 1191 /// FindPropertyImplIvarDecl - This method lookup the ivar in the list of 1192 /// properties implemented in this category \@implementation block and returns 1193 /// the implemented property that uses it. 1194 /// 1195 ObjCPropertyImplDecl *ObjCImplDecl:: 1196 FindPropertyImplIvarDecl(IdentifierInfo *ivarId) const { 1197 for (propimpl_iterator i = propimpl_begin(), e = propimpl_end(); i != e; ++i){ 1198 ObjCPropertyImplDecl *PID = *i; 1199 if (PID->getPropertyIvarDecl() && 1200 PID->getPropertyIvarDecl()->getIdentifier() == ivarId) 1201 return PID; 1202 } 1203 return 0; 1204 } 1205 1206 /// FindPropertyImplDecl - This method looks up a previous ObjCPropertyImplDecl 1207 /// added to the list of those properties \@synthesized/\@dynamic in this 1208 /// category \@implementation block. 1209 /// 1210 ObjCPropertyImplDecl *ObjCImplDecl:: 1211 FindPropertyImplDecl(IdentifierInfo *Id) const { 1212 for (propimpl_iterator i = propimpl_begin(), e = propimpl_end(); i != e; ++i){ 1213 ObjCPropertyImplDecl *PID = *i; 1214 if (PID->getPropertyDecl()->getIdentifier() == Id) 1215 return PID; 1216 } 1217 return 0; 1218 } 1219 1220 raw_ostream &clang::operator<<(raw_ostream &OS, 1221 const ObjCCategoryImplDecl &CID) { 1222 OS << CID.getName(); 1223 return OS; 1224 } 1225 1226 //===----------------------------------------------------------------------===// 1227 // ObjCImplementationDecl 1228 //===----------------------------------------------------------------------===// 1229 1230 void ObjCImplementationDecl::anchor() { } 1231 1232 ObjCImplementationDecl * 1233 ObjCImplementationDecl::Create(ASTContext &C, DeclContext *DC, 1234 ObjCInterfaceDecl *ClassInterface, 1235 ObjCInterfaceDecl *SuperDecl, 1236 SourceLocation nameLoc, 1237 SourceLocation atStartLoc, 1238 SourceLocation IvarLBraceLoc, 1239 SourceLocation IvarRBraceLoc) { 1240 if (ClassInterface && ClassInterface->hasDefinition()) 1241 ClassInterface = ClassInterface->getDefinition(); 1242 return new (C) ObjCImplementationDecl(DC, ClassInterface, SuperDecl, 1243 nameLoc, atStartLoc, 1244 IvarLBraceLoc, IvarRBraceLoc); 1245 } 1246 1247 ObjCImplementationDecl * 1248 ObjCImplementationDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 1249 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCImplementationDecl)); 1250 return new (Mem) ObjCImplementationDecl(0, 0, 0, SourceLocation(), 1251 SourceLocation()); 1252 } 1253 1254 void ObjCImplementationDecl::setIvarInitializers(ASTContext &C, 1255 CXXCtorInitializer ** initializers, 1256 unsigned numInitializers) { 1257 if (numInitializers > 0) { 1258 NumIvarInitializers = numInitializers; 1259 CXXCtorInitializer **ivarInitializers = 1260 new (C) CXXCtorInitializer*[NumIvarInitializers]; 1261 memcpy(ivarInitializers, initializers, 1262 numInitializers * sizeof(CXXCtorInitializer*)); 1263 IvarInitializers = ivarInitializers; 1264 } 1265 } 1266 1267 raw_ostream &clang::operator<<(raw_ostream &OS, 1268 const ObjCImplementationDecl &ID) { 1269 OS << ID.getName(); 1270 return OS; 1271 } 1272 1273 //===----------------------------------------------------------------------===// 1274 // ObjCCompatibleAliasDecl 1275 //===----------------------------------------------------------------------===// 1276 1277 void ObjCCompatibleAliasDecl::anchor() { } 1278 1279 ObjCCompatibleAliasDecl * 1280 ObjCCompatibleAliasDecl::Create(ASTContext &C, DeclContext *DC, 1281 SourceLocation L, 1282 IdentifierInfo *Id, 1283 ObjCInterfaceDecl* AliasedClass) { 1284 return new (C) ObjCCompatibleAliasDecl(DC, L, Id, AliasedClass); 1285 } 1286 1287 ObjCCompatibleAliasDecl * 1288 ObjCCompatibleAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 1289 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCCompatibleAliasDecl)); 1290 return new (Mem) ObjCCompatibleAliasDecl(0, SourceLocation(), 0, 0); 1291 } 1292 1293 //===----------------------------------------------------------------------===// 1294 // ObjCPropertyDecl 1295 //===----------------------------------------------------------------------===// 1296 1297 void ObjCPropertyDecl::anchor() { } 1298 1299 ObjCPropertyDecl *ObjCPropertyDecl::Create(ASTContext &C, DeclContext *DC, 1300 SourceLocation L, 1301 IdentifierInfo *Id, 1302 SourceLocation AtLoc, 1303 SourceLocation LParenLoc, 1304 TypeSourceInfo *T, 1305 PropertyControl propControl) { 1306 return new (C) ObjCPropertyDecl(DC, L, Id, AtLoc, LParenLoc, T); 1307 } 1308 1309 ObjCPropertyDecl *ObjCPropertyDecl::CreateDeserialized(ASTContext &C, 1310 unsigned ID) { 1311 void * Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCPropertyDecl)); 1312 return new (Mem) ObjCPropertyDecl(0, SourceLocation(), 0, SourceLocation(), 1313 SourceLocation(), 1314 0); 1315 } 1316 1317 //===----------------------------------------------------------------------===// 1318 // ObjCPropertyImplDecl 1319 //===----------------------------------------------------------------------===// 1320 1321 ObjCPropertyImplDecl *ObjCPropertyImplDecl::Create(ASTContext &C, 1322 DeclContext *DC, 1323 SourceLocation atLoc, 1324 SourceLocation L, 1325 ObjCPropertyDecl *property, 1326 Kind PK, 1327 ObjCIvarDecl *ivar, 1328 SourceLocation ivarLoc) { 1329 return new (C) ObjCPropertyImplDecl(DC, atLoc, L, property, PK, ivar, 1330 ivarLoc); 1331 } 1332 1333 ObjCPropertyImplDecl *ObjCPropertyImplDecl::CreateDeserialized(ASTContext &C, 1334 unsigned ID) { 1335 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCPropertyImplDecl)); 1336 return new (Mem) ObjCPropertyImplDecl(0, SourceLocation(), SourceLocation(), 1337 0, Dynamic, 0, SourceLocation()); 1338 } 1339 1340 SourceRange ObjCPropertyImplDecl::getSourceRange() const { 1341 SourceLocation EndLoc = getLocation(); 1342 if (IvarLoc.isValid()) 1343 EndLoc = IvarLoc; 1344 1345 return SourceRange(AtLoc, EndLoc); 1346 } 1347