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