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 ObjCMethodDecl *ObjCInterfaceDecl::lookupPrivateMethod( 367 const Selector &Sel, 368 bool Instance) { 369 // FIXME: Should make sure no callers ever do this. 370 if (!hasDefinition()) 371 return 0; 372 373 if (data().ExternallyCompleted) 374 LoadExternalDefinition(); 375 376 ObjCMethodDecl *Method = 0; 377 if (ObjCImplementationDecl *ImpDecl = getImplementation()) 378 Method = Instance ? ImpDecl->getInstanceMethod(Sel) 379 : ImpDecl->getClassMethod(Sel); 380 381 if (!Method && getSuperClass()) 382 return getSuperClass()->lookupPrivateMethod(Sel, Instance); 383 return Method; 384 } 385 386 //===----------------------------------------------------------------------===// 387 // ObjCMethodDecl 388 //===----------------------------------------------------------------------===// 389 390 ObjCMethodDecl *ObjCMethodDecl::Create(ASTContext &C, 391 SourceLocation beginLoc, 392 SourceLocation endLoc, 393 Selector SelInfo, QualType T, 394 TypeSourceInfo *ResultTInfo, 395 DeclContext *contextDecl, 396 bool isInstance, 397 bool isVariadic, 398 bool isSynthesized, 399 bool isImplicitlyDeclared, 400 bool isDefined, 401 ImplementationControl impControl, 402 bool HasRelatedResultType) { 403 return new (C) ObjCMethodDecl(beginLoc, endLoc, 404 SelInfo, T, ResultTInfo, contextDecl, 405 isInstance, 406 isVariadic, isSynthesized, isImplicitlyDeclared, 407 isDefined, 408 impControl, 409 HasRelatedResultType); 410 } 411 412 ObjCMethodDecl *ObjCMethodDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 413 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCMethodDecl)); 414 return new (Mem) ObjCMethodDecl(SourceLocation(), SourceLocation(), 415 Selector(), QualType(), 0, 0); 416 } 417 418 void ObjCMethodDecl::setAsRedeclaration(const ObjCMethodDecl *PrevMethod) { 419 assert(PrevMethod); 420 getASTContext().setObjCMethodRedeclaration(PrevMethod, this); 421 IsRedeclaration = true; 422 PrevMethod->HasRedeclaration = true; 423 } 424 425 void ObjCMethodDecl::setParamsAndSelLocs(ASTContext &C, 426 ArrayRef<ParmVarDecl*> Params, 427 ArrayRef<SourceLocation> SelLocs) { 428 ParamsAndSelLocs = 0; 429 NumParams = Params.size(); 430 if (Params.empty() && SelLocs.empty()) 431 return; 432 433 unsigned Size = sizeof(ParmVarDecl *) * NumParams + 434 sizeof(SourceLocation) * SelLocs.size(); 435 ParamsAndSelLocs = C.Allocate(Size); 436 std::copy(Params.begin(), Params.end(), getParams()); 437 std::copy(SelLocs.begin(), SelLocs.end(), getStoredSelLocs()); 438 } 439 440 void ObjCMethodDecl::getSelectorLocs( 441 SmallVectorImpl<SourceLocation> &SelLocs) const { 442 for (unsigned i = 0, e = getNumSelectorLocs(); i != e; ++i) 443 SelLocs.push_back(getSelectorLoc(i)); 444 } 445 446 void ObjCMethodDecl::setMethodParams(ASTContext &C, 447 ArrayRef<ParmVarDecl*> Params, 448 ArrayRef<SourceLocation> SelLocs) { 449 assert((!SelLocs.empty() || isImplicit()) && 450 "No selector locs for non-implicit method"); 451 if (isImplicit()) 452 return setParamsAndSelLocs(C, Params, ArrayRef<SourceLocation>()); 453 454 SelLocsKind = hasStandardSelectorLocs(getSelector(), SelLocs, Params, EndLoc); 455 if (SelLocsKind != SelLoc_NonStandard) 456 return setParamsAndSelLocs(C, Params, ArrayRef<SourceLocation>()); 457 458 setParamsAndSelLocs(C, Params, SelLocs); 459 } 460 461 /// \brief A definition will return its interface declaration. 462 /// An interface declaration will return its definition. 463 /// Otherwise it will return itself. 464 ObjCMethodDecl *ObjCMethodDecl::getNextRedeclaration() { 465 ASTContext &Ctx = getASTContext(); 466 ObjCMethodDecl *Redecl = 0; 467 if (HasRedeclaration) 468 Redecl = const_cast<ObjCMethodDecl*>(Ctx.getObjCMethodRedeclaration(this)); 469 if (Redecl) 470 return Redecl; 471 472 Decl *CtxD = cast<Decl>(getDeclContext()); 473 474 if (ObjCInterfaceDecl *IFD = dyn_cast<ObjCInterfaceDecl>(CtxD)) { 475 if (ObjCImplementationDecl *ImplD = Ctx.getObjCImplementation(IFD)) 476 Redecl = ImplD->getMethod(getSelector(), isInstanceMethod()); 477 478 } else if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CtxD)) { 479 if (ObjCCategoryImplDecl *ImplD = Ctx.getObjCImplementation(CD)) 480 Redecl = ImplD->getMethod(getSelector(), isInstanceMethod()); 481 482 } else if (ObjCImplementationDecl *ImplD = 483 dyn_cast<ObjCImplementationDecl>(CtxD)) { 484 if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface()) 485 Redecl = IFD->getMethod(getSelector(), isInstanceMethod()); 486 487 } else if (ObjCCategoryImplDecl *CImplD = 488 dyn_cast<ObjCCategoryImplDecl>(CtxD)) { 489 if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl()) 490 Redecl = CatD->getMethod(getSelector(), isInstanceMethod()); 491 } 492 493 if (!Redecl && isRedeclaration()) { 494 // This is the last redeclaration, go back to the first method. 495 return cast<ObjCContainerDecl>(CtxD)->getMethod(getSelector(), 496 isInstanceMethod()); 497 } 498 499 return Redecl ? Redecl : this; 500 } 501 502 ObjCMethodDecl *ObjCMethodDecl::getCanonicalDecl() { 503 Decl *CtxD = cast<Decl>(getDeclContext()); 504 505 if (ObjCImplementationDecl *ImplD = dyn_cast<ObjCImplementationDecl>(CtxD)) { 506 if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface()) 507 if (ObjCMethodDecl *MD = IFD->getMethod(getSelector(), 508 isInstanceMethod())) 509 return MD; 510 511 } else if (ObjCCategoryImplDecl *CImplD = 512 dyn_cast<ObjCCategoryImplDecl>(CtxD)) { 513 if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl()) 514 if (ObjCMethodDecl *MD = CatD->getMethod(getSelector(), 515 isInstanceMethod())) 516 return MD; 517 } 518 519 if (isRedeclaration()) 520 return cast<ObjCContainerDecl>(CtxD)->getMethod(getSelector(), 521 isInstanceMethod()); 522 523 return this; 524 } 525 526 ObjCMethodFamily ObjCMethodDecl::getMethodFamily() const { 527 ObjCMethodFamily family = static_cast<ObjCMethodFamily>(Family); 528 if (family != static_cast<unsigned>(InvalidObjCMethodFamily)) 529 return family; 530 531 // Check for an explicit attribute. 532 if (const ObjCMethodFamilyAttr *attr = getAttr<ObjCMethodFamilyAttr>()) { 533 // The unfortunate necessity of mapping between enums here is due 534 // to the attributes framework. 535 switch (attr->getFamily()) { 536 case ObjCMethodFamilyAttr::OMF_None: family = OMF_None; break; 537 case ObjCMethodFamilyAttr::OMF_alloc: family = OMF_alloc; break; 538 case ObjCMethodFamilyAttr::OMF_copy: family = OMF_copy; break; 539 case ObjCMethodFamilyAttr::OMF_init: family = OMF_init; break; 540 case ObjCMethodFamilyAttr::OMF_mutableCopy: family = OMF_mutableCopy; break; 541 case ObjCMethodFamilyAttr::OMF_new: family = OMF_new; break; 542 } 543 Family = static_cast<unsigned>(family); 544 return family; 545 } 546 547 family = getSelector().getMethodFamily(); 548 switch (family) { 549 case OMF_None: break; 550 551 // init only has a conventional meaning for an instance method, and 552 // it has to return an object. 553 case OMF_init: 554 if (!isInstanceMethod() || !getResultType()->isObjCObjectPointerType()) 555 family = OMF_None; 556 break; 557 558 // alloc/copy/new have a conventional meaning for both class and 559 // instance methods, but they require an object return. 560 case OMF_alloc: 561 case OMF_copy: 562 case OMF_mutableCopy: 563 case OMF_new: 564 if (!getResultType()->isObjCObjectPointerType()) 565 family = OMF_None; 566 break; 567 568 // These selectors have a conventional meaning only for instance methods. 569 case OMF_dealloc: 570 case OMF_finalize: 571 case OMF_retain: 572 case OMF_release: 573 case OMF_autorelease: 574 case OMF_retainCount: 575 case OMF_self: 576 if (!isInstanceMethod()) 577 family = OMF_None; 578 break; 579 580 case OMF_performSelector: 581 if (!isInstanceMethod() || 582 !getResultType()->isObjCIdType()) 583 family = OMF_None; 584 else { 585 unsigned noParams = param_size(); 586 if (noParams < 1 || noParams > 3) 587 family = OMF_None; 588 else { 589 ObjCMethodDecl::arg_type_iterator it = arg_type_begin(); 590 QualType ArgT = (*it); 591 if (!ArgT->isObjCSelType()) { 592 family = OMF_None; 593 break; 594 } 595 while (--noParams) { 596 it++; 597 ArgT = (*it); 598 if (!ArgT->isObjCIdType()) { 599 family = OMF_None; 600 break; 601 } 602 } 603 } 604 } 605 break; 606 607 } 608 609 // Cache the result. 610 Family = static_cast<unsigned>(family); 611 return family; 612 } 613 614 void ObjCMethodDecl::createImplicitParams(ASTContext &Context, 615 const ObjCInterfaceDecl *OID) { 616 QualType selfTy; 617 if (isInstanceMethod()) { 618 // There may be no interface context due to error in declaration 619 // of the interface (which has been reported). Recover gracefully. 620 if (OID) { 621 selfTy = Context.getObjCInterfaceType(OID); 622 selfTy = Context.getObjCObjectPointerType(selfTy); 623 } else { 624 selfTy = Context.getObjCIdType(); 625 } 626 } else // we have a factory method. 627 selfTy = Context.getObjCClassType(); 628 629 bool selfIsPseudoStrong = false; 630 bool selfIsConsumed = false; 631 632 if (Context.getLangOpts().ObjCAutoRefCount) { 633 if (isInstanceMethod()) { 634 selfIsConsumed = hasAttr<NSConsumesSelfAttr>(); 635 636 // 'self' is always __strong. It's actually pseudo-strong except 637 // in init methods (or methods labeled ns_consumes_self), though. 638 Qualifiers qs; 639 qs.setObjCLifetime(Qualifiers::OCL_Strong); 640 selfTy = Context.getQualifiedType(selfTy, qs); 641 642 // In addition, 'self' is const unless this is an init method. 643 if (getMethodFamily() != OMF_init && !selfIsConsumed) { 644 selfTy = selfTy.withConst(); 645 selfIsPseudoStrong = true; 646 } 647 } 648 else { 649 assert(isClassMethod()); 650 // 'self' is always const in class methods. 651 selfTy = selfTy.withConst(); 652 selfIsPseudoStrong = true; 653 } 654 } 655 656 ImplicitParamDecl *self 657 = ImplicitParamDecl::Create(Context, this, SourceLocation(), 658 &Context.Idents.get("self"), selfTy); 659 setSelfDecl(self); 660 661 if (selfIsConsumed) 662 self->addAttr(new (Context) NSConsumedAttr(SourceLocation(), Context)); 663 664 if (selfIsPseudoStrong) 665 self->setARCPseudoStrong(true); 666 667 setCmdDecl(ImplicitParamDecl::Create(Context, this, SourceLocation(), 668 &Context.Idents.get("_cmd"), 669 Context.getObjCSelType())); 670 } 671 672 ObjCInterfaceDecl *ObjCMethodDecl::getClassInterface() { 673 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(getDeclContext())) 674 return ID; 675 if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(getDeclContext())) 676 return CD->getClassInterface(); 677 if (ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(getDeclContext())) 678 return IMD->getClassInterface(); 679 680 assert(!isa<ObjCProtocolDecl>(getDeclContext()) && "It's a protocol method"); 681 llvm_unreachable("unknown method context"); 682 } 683 684 //===----------------------------------------------------------------------===// 685 // ObjCInterfaceDecl 686 //===----------------------------------------------------------------------===// 687 688 ObjCInterfaceDecl *ObjCInterfaceDecl::Create(const ASTContext &C, 689 DeclContext *DC, 690 SourceLocation atLoc, 691 IdentifierInfo *Id, 692 ObjCInterfaceDecl *PrevDecl, 693 SourceLocation ClassLoc, 694 bool isInternal){ 695 ObjCInterfaceDecl *Result = new (C) ObjCInterfaceDecl(DC, atLoc, Id, ClassLoc, 696 PrevDecl, isInternal); 697 C.getObjCInterfaceType(Result, PrevDecl); 698 return Result; 699 } 700 701 ObjCInterfaceDecl *ObjCInterfaceDecl::CreateDeserialized(ASTContext &C, 702 unsigned ID) { 703 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCInterfaceDecl)); 704 return new (Mem) ObjCInterfaceDecl(0, SourceLocation(), 0, SourceLocation(), 705 0, false); 706 } 707 708 ObjCInterfaceDecl:: 709 ObjCInterfaceDecl(DeclContext *DC, SourceLocation atLoc, IdentifierInfo *Id, 710 SourceLocation CLoc, ObjCInterfaceDecl *PrevDecl, 711 bool isInternal) 712 : ObjCContainerDecl(ObjCInterface, DC, Id, CLoc, atLoc), 713 TypeForDecl(0), Data() 714 { 715 setPreviousDeclaration(PrevDecl); 716 717 // Copy the 'data' pointer over. 718 if (PrevDecl) 719 Data = PrevDecl->Data; 720 721 setImplicit(isInternal); 722 } 723 724 void ObjCInterfaceDecl::LoadExternalDefinition() const { 725 assert(data().ExternallyCompleted && "Class is not externally completed"); 726 data().ExternallyCompleted = false; 727 getASTContext().getExternalSource()->CompleteType( 728 const_cast<ObjCInterfaceDecl *>(this)); 729 } 730 731 void ObjCInterfaceDecl::setExternallyCompleted() { 732 assert(getASTContext().getExternalSource() && 733 "Class can't be externally completed without an external source"); 734 assert(hasDefinition() && 735 "Forward declarations can't be externally completed"); 736 data().ExternallyCompleted = true; 737 } 738 739 ObjCImplementationDecl *ObjCInterfaceDecl::getImplementation() const { 740 if (const ObjCInterfaceDecl *Def = getDefinition()) { 741 if (data().ExternallyCompleted) 742 LoadExternalDefinition(); 743 744 return getASTContext().getObjCImplementation( 745 const_cast<ObjCInterfaceDecl*>(Def)); 746 } 747 748 // FIXME: Should make sure no callers ever do this. 749 return 0; 750 } 751 752 void ObjCInterfaceDecl::setImplementation(ObjCImplementationDecl *ImplD) { 753 getASTContext().setObjCImplementation(getDefinition(), ImplD); 754 } 755 756 /// all_declared_ivar_begin - return first ivar declared in this class, 757 /// its extensions and its implementation. Lazily build the list on first 758 /// access. 759 ObjCIvarDecl *ObjCInterfaceDecl::all_declared_ivar_begin() { 760 // FIXME: Should make sure no callers ever do this. 761 if (!hasDefinition()) 762 return 0; 763 764 if (data().IvarList) 765 return data().IvarList; 766 767 ObjCIvarDecl *curIvar = 0; 768 if (!ivar_empty()) { 769 ObjCInterfaceDecl::ivar_iterator I = ivar_begin(), E = ivar_end(); 770 data().IvarList = (*I); ++I; 771 for (curIvar = data().IvarList; I != E; curIvar = *I, ++I) 772 curIvar->setNextIvar(*I); 773 } 774 775 for (const ObjCCategoryDecl *CDecl = getFirstClassExtension(); CDecl; 776 CDecl = CDecl->getNextClassExtension()) { 777 if (!CDecl->ivar_empty()) { 778 ObjCCategoryDecl::ivar_iterator I = CDecl->ivar_begin(), 779 E = CDecl->ivar_end(); 780 if (!data().IvarList) { 781 data().IvarList = (*I); ++I; 782 curIvar = data().IvarList; 783 } 784 for ( ;I != E; curIvar = *I, ++I) 785 curIvar->setNextIvar(*I); 786 } 787 } 788 789 if (ObjCImplementationDecl *ImplDecl = getImplementation()) { 790 if (!ImplDecl->ivar_empty()) { 791 ObjCImplementationDecl::ivar_iterator I = ImplDecl->ivar_begin(), 792 E = ImplDecl->ivar_end(); 793 if (!data().IvarList) { 794 data().IvarList = (*I); ++I; 795 curIvar = data().IvarList; 796 } 797 for ( ;I != E; curIvar = *I, ++I) 798 curIvar->setNextIvar(*I); 799 } 800 } 801 return data().IvarList; 802 } 803 804 /// FindCategoryDeclaration - Finds category declaration in the list of 805 /// categories for this class and returns it. Name of the category is passed 806 /// in 'CategoryId'. If category not found, return 0; 807 /// 808 ObjCCategoryDecl * 809 ObjCInterfaceDecl::FindCategoryDeclaration(IdentifierInfo *CategoryId) const { 810 // FIXME: Should make sure no callers ever do this. 811 if (!hasDefinition()) 812 return 0; 813 814 if (data().ExternallyCompleted) 815 LoadExternalDefinition(); 816 817 for (ObjCCategoryDecl *Category = getCategoryList(); 818 Category; Category = Category->getNextClassCategory()) 819 if (Category->getIdentifier() == CategoryId) 820 return Category; 821 return 0; 822 } 823 824 ObjCMethodDecl * 825 ObjCInterfaceDecl::getCategoryInstanceMethod(Selector Sel) const { 826 for (ObjCCategoryDecl *Category = getCategoryList(); 827 Category; Category = Category->getNextClassCategory()) 828 if (ObjCCategoryImplDecl *Impl = Category->getImplementation()) 829 if (ObjCMethodDecl *MD = Impl->getInstanceMethod(Sel)) 830 return MD; 831 return 0; 832 } 833 834 ObjCMethodDecl *ObjCInterfaceDecl::getCategoryClassMethod(Selector Sel) const { 835 for (ObjCCategoryDecl *Category = getCategoryList(); 836 Category; Category = Category->getNextClassCategory()) 837 if (ObjCCategoryImplDecl *Impl = Category->getImplementation()) 838 if (ObjCMethodDecl *MD = Impl->getClassMethod(Sel)) 839 return MD; 840 return 0; 841 } 842 843 /// ClassImplementsProtocol - Checks that 'lProto' protocol 844 /// has been implemented in IDecl class, its super class or categories (if 845 /// lookupCategory is true). 846 bool ObjCInterfaceDecl::ClassImplementsProtocol(ObjCProtocolDecl *lProto, 847 bool lookupCategory, 848 bool RHSIsQualifiedID) { 849 if (!hasDefinition()) 850 return false; 851 852 ObjCInterfaceDecl *IDecl = this; 853 // 1st, look up the class. 854 for (ObjCInterfaceDecl::protocol_iterator 855 PI = IDecl->protocol_begin(), E = IDecl->protocol_end(); PI != E; ++PI){ 856 if (getASTContext().ProtocolCompatibleWithProtocol(lProto, *PI)) 857 return true; 858 // This is dubious and is added to be compatible with gcc. In gcc, it is 859 // also allowed assigning a protocol-qualified 'id' type to a LHS object 860 // when protocol in qualified LHS is in list of protocols in the rhs 'id' 861 // object. This IMO, should be a bug. 862 // FIXME: Treat this as an extension, and flag this as an error when GCC 863 // extensions are not enabled. 864 if (RHSIsQualifiedID && 865 getASTContext().ProtocolCompatibleWithProtocol(*PI, lProto)) 866 return true; 867 } 868 869 // 2nd, look up the category. 870 if (lookupCategory) 871 for (ObjCCategoryDecl *CDecl = IDecl->getCategoryList(); CDecl; 872 CDecl = CDecl->getNextClassCategory()) { 873 for (ObjCCategoryDecl::protocol_iterator PI = CDecl->protocol_begin(), 874 E = CDecl->protocol_end(); PI != E; ++PI) 875 if (getASTContext().ProtocolCompatibleWithProtocol(lProto, *PI)) 876 return true; 877 } 878 879 // 3rd, look up the super class(s) 880 if (IDecl->getSuperClass()) 881 return 882 IDecl->getSuperClass()->ClassImplementsProtocol(lProto, lookupCategory, 883 RHSIsQualifiedID); 884 885 return false; 886 } 887 888 //===----------------------------------------------------------------------===// 889 // ObjCIvarDecl 890 //===----------------------------------------------------------------------===// 891 892 void ObjCIvarDecl::anchor() { } 893 894 ObjCIvarDecl *ObjCIvarDecl::Create(ASTContext &C, ObjCContainerDecl *DC, 895 SourceLocation StartLoc, 896 SourceLocation IdLoc, IdentifierInfo *Id, 897 QualType T, TypeSourceInfo *TInfo, 898 AccessControl ac, Expr *BW, 899 bool synthesized) { 900 if (DC) { 901 // Ivar's can only appear in interfaces, implementations (via synthesized 902 // properties), and class extensions (via direct declaration, or synthesized 903 // properties). 904 // 905 // FIXME: This should really be asserting this: 906 // (isa<ObjCCategoryDecl>(DC) && 907 // cast<ObjCCategoryDecl>(DC)->IsClassExtension())) 908 // but unfortunately we sometimes place ivars into non-class extension 909 // categories on error. This breaks an AST invariant, and should not be 910 // fixed. 911 assert((isa<ObjCInterfaceDecl>(DC) || isa<ObjCImplementationDecl>(DC) || 912 isa<ObjCCategoryDecl>(DC)) && 913 "Invalid ivar decl context!"); 914 // Once a new ivar is created in any of class/class-extension/implementation 915 // decl contexts, the previously built IvarList must be rebuilt. 916 ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(DC); 917 if (!ID) { 918 if (ObjCImplementationDecl *IM = dyn_cast<ObjCImplementationDecl>(DC)) { 919 ID = IM->getClassInterface(); 920 if (BW) 921 IM->setHasSynthBitfield(true); 922 } else { 923 ObjCCategoryDecl *CD = cast<ObjCCategoryDecl>(DC); 924 ID = CD->getClassInterface(); 925 if (BW) 926 CD->setHasSynthBitfield(true); 927 } 928 } 929 ID->setIvarList(0); 930 } 931 932 return new (C) ObjCIvarDecl(DC, StartLoc, IdLoc, Id, T, TInfo, 933 ac, BW, synthesized); 934 } 935 936 ObjCIvarDecl *ObjCIvarDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 937 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCIvarDecl)); 938 return new (Mem) ObjCIvarDecl(0, SourceLocation(), SourceLocation(), 0, 939 QualType(), 0, ObjCIvarDecl::None, 0, false); 940 } 941 942 const ObjCInterfaceDecl *ObjCIvarDecl::getContainingInterface() const { 943 const ObjCContainerDecl *DC = cast<ObjCContainerDecl>(getDeclContext()); 944 945 switch (DC->getKind()) { 946 default: 947 case ObjCCategoryImpl: 948 case ObjCProtocol: 949 llvm_unreachable("invalid ivar container!"); 950 951 // Ivars can only appear in class extension categories. 952 case ObjCCategory: { 953 const ObjCCategoryDecl *CD = cast<ObjCCategoryDecl>(DC); 954 assert(CD->IsClassExtension() && "invalid container for ivar!"); 955 return CD->getClassInterface(); 956 } 957 958 case ObjCImplementation: 959 return cast<ObjCImplementationDecl>(DC)->getClassInterface(); 960 961 case ObjCInterface: 962 return cast<ObjCInterfaceDecl>(DC); 963 } 964 } 965 966 //===----------------------------------------------------------------------===// 967 // ObjCAtDefsFieldDecl 968 //===----------------------------------------------------------------------===// 969 970 void ObjCAtDefsFieldDecl::anchor() { } 971 972 ObjCAtDefsFieldDecl 973 *ObjCAtDefsFieldDecl::Create(ASTContext &C, DeclContext *DC, 974 SourceLocation StartLoc, SourceLocation IdLoc, 975 IdentifierInfo *Id, QualType T, Expr *BW) { 976 return new (C) ObjCAtDefsFieldDecl(DC, StartLoc, IdLoc, Id, T, BW); 977 } 978 979 ObjCAtDefsFieldDecl *ObjCAtDefsFieldDecl::CreateDeserialized(ASTContext &C, 980 unsigned ID) { 981 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCAtDefsFieldDecl)); 982 return new (Mem) ObjCAtDefsFieldDecl(0, SourceLocation(), SourceLocation(), 983 0, QualType(), 0); 984 } 985 986 //===----------------------------------------------------------------------===// 987 // ObjCProtocolDecl 988 //===----------------------------------------------------------------------===// 989 990 void ObjCProtocolDecl::anchor() { } 991 992 ObjCProtocolDecl::ObjCProtocolDecl(DeclContext *DC, IdentifierInfo *Id, 993 SourceLocation nameLoc, 994 SourceLocation atStartLoc, 995 ObjCProtocolDecl *PrevDecl) 996 : ObjCContainerDecl(ObjCProtocol, DC, Id, nameLoc, atStartLoc), Data() 997 { 998 setPreviousDeclaration(PrevDecl); 999 if (PrevDecl) 1000 Data = PrevDecl->Data; 1001 } 1002 1003 ObjCProtocolDecl *ObjCProtocolDecl::Create(ASTContext &C, DeclContext *DC, 1004 IdentifierInfo *Id, 1005 SourceLocation nameLoc, 1006 SourceLocation atStartLoc, 1007 ObjCProtocolDecl *PrevDecl) { 1008 ObjCProtocolDecl *Result 1009 = new (C) ObjCProtocolDecl(DC, Id, nameLoc, atStartLoc, PrevDecl); 1010 1011 return Result; 1012 } 1013 1014 ObjCProtocolDecl *ObjCProtocolDecl::CreateDeserialized(ASTContext &C, 1015 unsigned ID) { 1016 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCProtocolDecl)); 1017 return new (Mem) ObjCProtocolDecl(0, 0, SourceLocation(), SourceLocation(), 1018 0); 1019 } 1020 1021 ObjCProtocolDecl *ObjCProtocolDecl::lookupProtocolNamed(IdentifierInfo *Name) { 1022 ObjCProtocolDecl *PDecl = this; 1023 1024 if (Name == getIdentifier()) 1025 return PDecl; 1026 1027 for (protocol_iterator I = protocol_begin(), E = protocol_end(); I != E; ++I) 1028 if ((PDecl = (*I)->lookupProtocolNamed(Name))) 1029 return PDecl; 1030 1031 return NULL; 1032 } 1033 1034 // lookupMethod - Lookup a instance/class method in the protocol and protocols 1035 // it inherited. 1036 ObjCMethodDecl *ObjCProtocolDecl::lookupMethod(Selector Sel, 1037 bool isInstance) const { 1038 ObjCMethodDecl *MethodDecl = NULL; 1039 1040 if ((MethodDecl = getMethod(Sel, isInstance))) 1041 return MethodDecl; 1042 1043 for (protocol_iterator I = protocol_begin(), E = protocol_end(); I != E; ++I) 1044 if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance))) 1045 return MethodDecl; 1046 return NULL; 1047 } 1048 1049 void ObjCProtocolDecl::allocateDefinitionData() { 1050 assert(!Data && "Protocol already has a definition!"); 1051 Data = new (getASTContext()) DefinitionData; 1052 Data->Definition = this; 1053 } 1054 1055 void ObjCProtocolDecl::startDefinition() { 1056 allocateDefinitionData(); 1057 1058 // Update all of the declarations with a pointer to the definition. 1059 for (redecl_iterator RD = redecls_begin(), RDEnd = redecls_end(); 1060 RD != RDEnd; ++RD) 1061 RD->Data = this->Data; 1062 } 1063 1064 //===----------------------------------------------------------------------===// 1065 // ObjCCategoryDecl 1066 //===----------------------------------------------------------------------===// 1067 1068 void ObjCCategoryDecl::anchor() { } 1069 1070 ObjCCategoryDecl *ObjCCategoryDecl::Create(ASTContext &C, DeclContext *DC, 1071 SourceLocation AtLoc, 1072 SourceLocation ClassNameLoc, 1073 SourceLocation CategoryNameLoc, 1074 IdentifierInfo *Id, 1075 ObjCInterfaceDecl *IDecl, 1076 SourceLocation IvarLBraceLoc, 1077 SourceLocation IvarRBraceLoc) { 1078 ObjCCategoryDecl *CatDecl = new (C) ObjCCategoryDecl(DC, AtLoc, ClassNameLoc, 1079 CategoryNameLoc, Id, 1080 IDecl, 1081 IvarLBraceLoc, IvarRBraceLoc); 1082 if (IDecl) { 1083 // Link this category into its class's category list. 1084 CatDecl->NextClassCategory = IDecl->getCategoryList(); 1085 if (IDecl->hasDefinition()) { 1086 IDecl->setCategoryList(CatDecl); 1087 if (ASTMutationListener *L = C.getASTMutationListener()) 1088 L->AddedObjCCategoryToInterface(CatDecl, IDecl); 1089 } 1090 } 1091 1092 return CatDecl; 1093 } 1094 1095 ObjCCategoryDecl *ObjCCategoryDecl::CreateDeserialized(ASTContext &C, 1096 unsigned ID) { 1097 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCCategoryDecl)); 1098 return new (Mem) ObjCCategoryDecl(0, SourceLocation(), SourceLocation(), 1099 SourceLocation(), 0, 0); 1100 } 1101 1102 ObjCCategoryImplDecl *ObjCCategoryDecl::getImplementation() const { 1103 return getASTContext().getObjCImplementation( 1104 const_cast<ObjCCategoryDecl*>(this)); 1105 } 1106 1107 void ObjCCategoryDecl::setImplementation(ObjCCategoryImplDecl *ImplD) { 1108 getASTContext().setObjCImplementation(this, ImplD); 1109 } 1110 1111 1112 //===----------------------------------------------------------------------===// 1113 // ObjCCategoryImplDecl 1114 //===----------------------------------------------------------------------===// 1115 1116 void ObjCCategoryImplDecl::anchor() { } 1117 1118 ObjCCategoryImplDecl * 1119 ObjCCategoryImplDecl::Create(ASTContext &C, DeclContext *DC, 1120 IdentifierInfo *Id, 1121 ObjCInterfaceDecl *ClassInterface, 1122 SourceLocation nameLoc, 1123 SourceLocation atStartLoc, 1124 SourceLocation CategoryNameLoc) { 1125 if (ClassInterface && ClassInterface->hasDefinition()) 1126 ClassInterface = ClassInterface->getDefinition(); 1127 return new (C) ObjCCategoryImplDecl(DC, Id, ClassInterface, 1128 nameLoc, atStartLoc, CategoryNameLoc); 1129 } 1130 1131 ObjCCategoryImplDecl *ObjCCategoryImplDecl::CreateDeserialized(ASTContext &C, 1132 unsigned ID) { 1133 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCCategoryImplDecl)); 1134 return new (Mem) ObjCCategoryImplDecl(0, 0, 0, SourceLocation(), 1135 SourceLocation(), SourceLocation()); 1136 } 1137 1138 ObjCCategoryDecl *ObjCCategoryImplDecl::getCategoryDecl() const { 1139 // The class interface might be NULL if we are working with invalid code. 1140 if (const ObjCInterfaceDecl *ID = getClassInterface()) 1141 return ID->FindCategoryDeclaration(getIdentifier()); 1142 return 0; 1143 } 1144 1145 1146 void ObjCImplDecl::anchor() { } 1147 1148 void ObjCImplDecl::addPropertyImplementation(ObjCPropertyImplDecl *property) { 1149 // FIXME: The context should be correct before we get here. 1150 property->setLexicalDeclContext(this); 1151 addDecl(property); 1152 } 1153 1154 void ObjCImplDecl::setClassInterface(ObjCInterfaceDecl *IFace) { 1155 ASTContext &Ctx = getASTContext(); 1156 1157 if (ObjCImplementationDecl *ImplD 1158 = dyn_cast_or_null<ObjCImplementationDecl>(this)) { 1159 if (IFace) 1160 Ctx.setObjCImplementation(IFace, ImplD); 1161 1162 } else if (ObjCCategoryImplDecl *ImplD = 1163 dyn_cast_or_null<ObjCCategoryImplDecl>(this)) { 1164 if (ObjCCategoryDecl *CD = IFace->FindCategoryDeclaration(getIdentifier())) 1165 Ctx.setObjCImplementation(CD, ImplD); 1166 } 1167 1168 ClassInterface = IFace; 1169 } 1170 1171 /// FindPropertyImplIvarDecl - This method lookup the ivar in the list of 1172 /// properties implemented in this category @implementation block and returns 1173 /// the implemented property that uses it. 1174 /// 1175 ObjCPropertyImplDecl *ObjCImplDecl:: 1176 FindPropertyImplIvarDecl(IdentifierInfo *ivarId) const { 1177 for (propimpl_iterator i = propimpl_begin(), e = propimpl_end(); i != e; ++i){ 1178 ObjCPropertyImplDecl *PID = *i; 1179 if (PID->getPropertyIvarDecl() && 1180 PID->getPropertyIvarDecl()->getIdentifier() == ivarId) 1181 return PID; 1182 } 1183 return 0; 1184 } 1185 1186 /// FindPropertyImplDecl - This method looks up a previous ObjCPropertyImplDecl 1187 /// added to the list of those properties @synthesized/@dynamic in this 1188 /// category @implementation block. 1189 /// 1190 ObjCPropertyImplDecl *ObjCImplDecl:: 1191 FindPropertyImplDecl(IdentifierInfo *Id) const { 1192 for (propimpl_iterator i = propimpl_begin(), e = propimpl_end(); i != e; ++i){ 1193 ObjCPropertyImplDecl *PID = *i; 1194 if (PID->getPropertyDecl()->getIdentifier() == Id) 1195 return PID; 1196 } 1197 return 0; 1198 } 1199 1200 raw_ostream &clang::operator<<(raw_ostream &OS, 1201 const ObjCCategoryImplDecl &CID) { 1202 OS << CID.getName(); 1203 return OS; 1204 } 1205 1206 //===----------------------------------------------------------------------===// 1207 // ObjCImplementationDecl 1208 //===----------------------------------------------------------------------===// 1209 1210 void ObjCImplementationDecl::anchor() { } 1211 1212 ObjCImplementationDecl * 1213 ObjCImplementationDecl::Create(ASTContext &C, DeclContext *DC, 1214 ObjCInterfaceDecl *ClassInterface, 1215 ObjCInterfaceDecl *SuperDecl, 1216 SourceLocation nameLoc, 1217 SourceLocation atStartLoc, 1218 SourceLocation IvarLBraceLoc, 1219 SourceLocation IvarRBraceLoc) { 1220 if (ClassInterface && ClassInterface->hasDefinition()) 1221 ClassInterface = ClassInterface->getDefinition(); 1222 return new (C) ObjCImplementationDecl(DC, ClassInterface, SuperDecl, 1223 nameLoc, atStartLoc, 1224 IvarLBraceLoc, IvarRBraceLoc); 1225 } 1226 1227 ObjCImplementationDecl * 1228 ObjCImplementationDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 1229 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCImplementationDecl)); 1230 return new (Mem) ObjCImplementationDecl(0, 0, 0, SourceLocation(), 1231 SourceLocation()); 1232 } 1233 1234 void ObjCImplementationDecl::setIvarInitializers(ASTContext &C, 1235 CXXCtorInitializer ** initializers, 1236 unsigned numInitializers) { 1237 if (numInitializers > 0) { 1238 NumIvarInitializers = numInitializers; 1239 CXXCtorInitializer **ivarInitializers = 1240 new (C) CXXCtorInitializer*[NumIvarInitializers]; 1241 memcpy(ivarInitializers, initializers, 1242 numInitializers * sizeof(CXXCtorInitializer*)); 1243 IvarInitializers = ivarInitializers; 1244 } 1245 } 1246 1247 raw_ostream &clang::operator<<(raw_ostream &OS, 1248 const ObjCImplementationDecl &ID) { 1249 OS << ID.getName(); 1250 return OS; 1251 } 1252 1253 //===----------------------------------------------------------------------===// 1254 // ObjCCompatibleAliasDecl 1255 //===----------------------------------------------------------------------===// 1256 1257 void ObjCCompatibleAliasDecl::anchor() { } 1258 1259 ObjCCompatibleAliasDecl * 1260 ObjCCompatibleAliasDecl::Create(ASTContext &C, DeclContext *DC, 1261 SourceLocation L, 1262 IdentifierInfo *Id, 1263 ObjCInterfaceDecl* AliasedClass) { 1264 return new (C) ObjCCompatibleAliasDecl(DC, L, Id, AliasedClass); 1265 } 1266 1267 ObjCCompatibleAliasDecl * 1268 ObjCCompatibleAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 1269 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCCompatibleAliasDecl)); 1270 return new (Mem) ObjCCompatibleAliasDecl(0, SourceLocation(), 0, 0); 1271 } 1272 1273 //===----------------------------------------------------------------------===// 1274 // ObjCPropertyDecl 1275 //===----------------------------------------------------------------------===// 1276 1277 void ObjCPropertyDecl::anchor() { } 1278 1279 ObjCPropertyDecl *ObjCPropertyDecl::Create(ASTContext &C, DeclContext *DC, 1280 SourceLocation L, 1281 IdentifierInfo *Id, 1282 SourceLocation AtLoc, 1283 SourceLocation LParenLoc, 1284 TypeSourceInfo *T, 1285 PropertyControl propControl) { 1286 return new (C) ObjCPropertyDecl(DC, L, Id, AtLoc, LParenLoc, T); 1287 } 1288 1289 ObjCPropertyDecl *ObjCPropertyDecl::CreateDeserialized(ASTContext &C, 1290 unsigned ID) { 1291 void * Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCPropertyDecl)); 1292 return new (Mem) ObjCPropertyDecl(0, SourceLocation(), 0, SourceLocation(), 1293 SourceLocation(), 1294 0); 1295 } 1296 1297 //===----------------------------------------------------------------------===// 1298 // ObjCPropertyImplDecl 1299 //===----------------------------------------------------------------------===// 1300 1301 ObjCPropertyImplDecl *ObjCPropertyImplDecl::Create(ASTContext &C, 1302 DeclContext *DC, 1303 SourceLocation atLoc, 1304 SourceLocation L, 1305 ObjCPropertyDecl *property, 1306 Kind PK, 1307 ObjCIvarDecl *ivar, 1308 SourceLocation ivarLoc) { 1309 return new (C) ObjCPropertyImplDecl(DC, atLoc, L, property, PK, ivar, 1310 ivarLoc); 1311 } 1312 1313 ObjCPropertyImplDecl *ObjCPropertyImplDecl::CreateDeserialized(ASTContext &C, 1314 unsigned ID) { 1315 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ObjCPropertyImplDecl)); 1316 return new (Mem) ObjCPropertyImplDecl(0, SourceLocation(), SourceLocation(), 1317 0, Dynamic, 0, SourceLocation()); 1318 } 1319 1320 SourceRange ObjCPropertyImplDecl::getSourceRange() const { 1321 SourceLocation EndLoc = getLocation(); 1322 if (IvarLoc.isValid()) 1323 EndLoc = IvarLoc; 1324 1325 return SourceRange(AtLoc, EndLoc); 1326 } 1327