SemaDeclObjC.cpp revision 50956e4675a87c2f9f81b6f8367146e066e8f8eb
1//===--- SemaDeclObjC.cpp - Semantic Analysis for ObjC Declarations -------===// 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 semantic analysis for Objective C declarations. 11// 12//===----------------------------------------------------------------------===// 13 14#include "Sema.h" 15#include "clang/AST/ASTContext.h" 16#include "clang/AST/DeclObjC.h" 17#include "clang/Parse/DeclSpec.h" 18using namespace clang; 19 20/// ObjCActOnStartOfMethodDef - This routine sets up parameters; invisible 21/// and user declared, in the method definition's AST. 22void Sema::ObjCActOnStartOfMethodDef(Scope *FnBodyScope, DeclTy *D) { 23 assert(getCurMethodDecl() == 0 && "Method parsing confused"); 24 ObjCMethodDecl *MDecl = dyn_cast_or_null<ObjCMethodDecl>((Decl *)D); 25 26 // If we don't have a valid method decl, simply return. 27 if (!MDecl) 28 return; 29 30 // Allow the rest of sema to find private method decl implementations. 31 if (MDecl->isInstanceMethod()) 32 AddInstanceMethodToGlobalPool(MDecl); 33 else 34 AddFactoryMethodToGlobalPool(MDecl); 35 36 // Allow all of Sema to see that we are entering a method definition. 37 PushDeclContext(FnBodyScope, MDecl); 38 39 // Create Decl objects for each parameter, entrring them in the scope for 40 // binding to their use. 41 42 // Insert the invisible arguments, self and _cmd! 43 MDecl->createImplicitParams(Context, MDecl->getClassInterface()); 44 45 PushOnScopeChains(MDecl->getSelfDecl(), FnBodyScope); 46 PushOnScopeChains(MDecl->getCmdDecl(), FnBodyScope); 47 48 // Introduce all of the other parameters into this scope. 49 for (ObjCMethodDecl::param_iterator PI = MDecl->param_begin(), 50 E = MDecl->param_end(); PI != E; ++PI) 51 if ((*PI)->getIdentifier()) 52 PushOnScopeChains(*PI, FnBodyScope); 53} 54 55Sema::DeclTy *Sema:: 56ActOnStartClassInterface(SourceLocation AtInterfaceLoc, 57 IdentifierInfo *ClassName, SourceLocation ClassLoc, 58 IdentifierInfo *SuperName, SourceLocation SuperLoc, 59 DeclTy * const *ProtoRefs, unsigned NumProtoRefs, 60 SourceLocation EndProtoLoc, AttributeList *AttrList) { 61 assert(ClassName && "Missing class identifier"); 62 63 // Check for another declaration kind with the same name. 64 NamedDecl *PrevDecl = LookupName(TUScope, ClassName, LookupOrdinaryName); 65 if (PrevDecl && PrevDecl->isTemplateParameter()) { 66 // Maybe we will complain about the shadowed template parameter. 67 DiagnoseTemplateParameterShadow(ClassLoc, PrevDecl); 68 // Just pretend that we didn't see the previous declaration. 69 PrevDecl = 0; 70 } 71 72 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) { 73 Diag(ClassLoc, diag::err_redefinition_different_kind) << ClassName; 74 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 75 } 76 77 ObjCInterfaceDecl* IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl); 78 if (IDecl) { 79 // Class already seen. Is it a forward declaration? 80 if (!IDecl->isForwardDecl()) { 81 IDecl->setInvalidDecl(); 82 Diag(AtInterfaceLoc, diag::err_duplicate_class_def)<<IDecl->getDeclName(); 83 Diag(IDecl->getLocation(), diag::note_previous_definition); 84 85 // Return the previous class interface. 86 // FIXME: don't leak the objects passed in! 87 return IDecl; 88 } else { 89 IDecl->setLocation(AtInterfaceLoc); 90 IDecl->setForwardDecl(false); 91 } 92 } else { 93 IDecl = ObjCInterfaceDecl::Create(Context, CurContext, AtInterfaceLoc, 94 ClassName, ClassLoc); 95 if (AttrList) 96 ProcessDeclAttributeList(IDecl, AttrList); 97 98 ObjCInterfaceDecls[ClassName] = IDecl; 99 // FIXME: PushOnScopeChains 100 CurContext->addDecl(IDecl); 101 // Remember that this needs to be removed when the scope is popped. 102 TUScope->AddDecl(IDecl); 103 } 104 105 if (SuperName) { 106 // Check if a different kind of symbol declared in this scope. 107 PrevDecl = LookupName(TUScope, SuperName, LookupOrdinaryName); 108 109 ObjCInterfaceDecl *SuperClassDecl = 110 dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl); 111 112 // Diagnose classes that inherit from deprecated classes. 113 if (SuperClassDecl) 114 (void)DiagnoseUseOfDecl(SuperClassDecl, SuperLoc); 115 116 if (PrevDecl && SuperClassDecl == 0) { 117 // The previous declaration was not a class decl. Check if we have a 118 // typedef. If we do, get the underlying class type. 119 if (const TypedefDecl *TDecl = dyn_cast_or_null<TypedefDecl>(PrevDecl)) { 120 QualType T = TDecl->getUnderlyingType(); 121 if (T->isObjCInterfaceType()) { 122 if (NamedDecl *IDecl = T->getAsObjCInterfaceType()->getDecl()) 123 SuperClassDecl = dyn_cast<ObjCInterfaceDecl>(IDecl); 124 } 125 } 126 127 // This handles the following case: 128 // 129 // typedef int SuperClass; 130 // @interface MyClass : SuperClass {} @end 131 // 132 if (!SuperClassDecl) { 133 Diag(SuperLoc, diag::err_redefinition_different_kind) << SuperName; 134 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 135 } 136 } 137 138 if (!dyn_cast_or_null<TypedefDecl>(PrevDecl)) { 139 if (!SuperClassDecl) 140 Diag(SuperLoc, diag::err_undef_superclass) 141 << SuperName << ClassName << SourceRange(AtInterfaceLoc, ClassLoc); 142 else if (SuperClassDecl->isForwardDecl()) 143 Diag(SuperLoc, diag::err_undef_superclass) 144 << SuperClassDecl->getDeclName() << ClassName 145 << SourceRange(AtInterfaceLoc, ClassLoc); 146 } 147 IDecl->setSuperClass(SuperClassDecl); 148 IDecl->setSuperClassLoc(SuperLoc); 149 IDecl->setLocEnd(SuperLoc); 150 } else { // we have a root class. 151 IDecl->setLocEnd(ClassLoc); 152 } 153 154 /// Check then save referenced protocols. 155 if (NumProtoRefs) { 156 IDecl->setProtocolList((ObjCProtocolDecl**)ProtoRefs, NumProtoRefs, 157 Context); 158 IDecl->setLocEnd(EndProtoLoc); 159 } 160 161 CheckObjCDeclScope(IDecl); 162 return IDecl; 163} 164 165/// ActOnCompatiblityAlias - this action is called after complete parsing of 166/// @compatibility_alias declaration. It sets up the alias relationships. 167Sema::DeclTy *Sema::ActOnCompatiblityAlias(SourceLocation AtLoc, 168 IdentifierInfo *AliasName, 169 SourceLocation AliasLocation, 170 IdentifierInfo *ClassName, 171 SourceLocation ClassLocation) { 172 // Look for previous declaration of alias name 173 NamedDecl *ADecl = LookupName(TUScope, AliasName, LookupOrdinaryName); 174 if (ADecl) { 175 if (isa<ObjCCompatibleAliasDecl>(ADecl)) 176 Diag(AliasLocation, diag::warn_previous_alias_decl); 177 else 178 Diag(AliasLocation, diag::err_conflicting_aliasing_type) << AliasName; 179 Diag(ADecl->getLocation(), diag::note_previous_declaration); 180 return 0; 181 } 182 // Check for class declaration 183 NamedDecl *CDeclU = LookupName(TUScope, ClassName, LookupOrdinaryName); 184 if (const TypedefDecl *TDecl = dyn_cast_or_null<TypedefDecl>(CDeclU)) { 185 QualType T = TDecl->getUnderlyingType(); 186 if (T->isObjCInterfaceType()) { 187 if (NamedDecl *IDecl = T->getAsObjCInterfaceType()->getDecl()) { 188 ClassName = IDecl->getIdentifier(); 189 CDeclU = LookupName(TUScope, ClassName, LookupOrdinaryName); 190 } 191 } 192 } 193 ObjCInterfaceDecl *CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(CDeclU); 194 if (CDecl == 0) { 195 Diag(ClassLocation, diag::warn_undef_interface) << ClassName; 196 if (CDeclU) 197 Diag(CDeclU->getLocation(), diag::note_previous_declaration); 198 return 0; 199 } 200 201 // Everything checked out, instantiate a new alias declaration AST. 202 ObjCCompatibleAliasDecl *AliasDecl = 203 ObjCCompatibleAliasDecl::Create(Context, CurContext, AtLoc, AliasName, CDecl); 204 205 ObjCAliasDecls[AliasName] = AliasDecl; 206 207 // FIXME: PushOnScopeChains? 208 CurContext->addDecl(AliasDecl); 209 if (!CheckObjCDeclScope(AliasDecl)) 210 TUScope->AddDecl(AliasDecl); 211 212 return AliasDecl; 213} 214 215Sema::DeclTy * 216Sema::ActOnStartProtocolInterface(SourceLocation AtProtoInterfaceLoc, 217 IdentifierInfo *ProtocolName, 218 SourceLocation ProtocolLoc, 219 DeclTy * const *ProtoRefs, 220 unsigned NumProtoRefs, 221 SourceLocation EndProtoLoc, 222 AttributeList *AttrList) { 223 // FIXME: Deal with AttrList. 224 assert(ProtocolName && "Missing protocol identifier"); 225 ObjCProtocolDecl *PDecl = ObjCProtocols[ProtocolName]; 226 if (PDecl) { 227 // Protocol already seen. Better be a forward protocol declaration 228 if (!PDecl->isForwardDecl()) { 229 PDecl->setInvalidDecl(); 230 Diag(ProtocolLoc, diag::err_duplicate_protocol_def) << ProtocolName; 231 Diag(PDecl->getLocation(), diag::note_previous_definition); 232 // Just return the protocol we already had. 233 // FIXME: don't leak the objects passed in! 234 return PDecl; 235 } 236 // Make sure the cached decl gets a valid start location. 237 PDecl->setLocation(AtProtoInterfaceLoc); 238 PDecl->setForwardDecl(false); 239 } else { 240 PDecl = ObjCProtocolDecl::Create(Context, CurContext, 241 AtProtoInterfaceLoc,ProtocolName); 242 // FIXME: PushOnScopeChains? 243 CurContext->addDecl(PDecl); 244 PDecl->setForwardDecl(false); 245 ObjCProtocols[ProtocolName] = PDecl; 246 } 247 if (AttrList) 248 ProcessDeclAttributeList(PDecl, AttrList); 249 if (NumProtoRefs) { 250 /// Check then save referenced protocols. 251 PDecl->setProtocolList((ObjCProtocolDecl**)ProtoRefs, NumProtoRefs,Context); 252 PDecl->setLocEnd(EndProtoLoc); 253 } 254 255 CheckObjCDeclScope(PDecl); 256 return PDecl; 257} 258 259/// FindProtocolDeclaration - This routine looks up protocols and 260/// issues an error if they are not declared. It returns list of 261/// protocol declarations in its 'Protocols' argument. 262void 263Sema::FindProtocolDeclaration(bool WarnOnDeclarations, 264 const IdentifierLocPair *ProtocolId, 265 unsigned NumProtocols, 266 llvm::SmallVectorImpl<DeclTy*> &Protocols) { 267 for (unsigned i = 0; i != NumProtocols; ++i) { 268 ObjCProtocolDecl *PDecl = ObjCProtocols[ProtocolId[i].first]; 269 if (!PDecl) { 270 Diag(ProtocolId[i].second, diag::err_undeclared_protocol) 271 << ProtocolId[i].first; 272 continue; 273 } 274 275 (void)DiagnoseUseOfDecl(PDecl, ProtocolId[i].second); 276 277 // If this is a forward declaration and we are supposed to warn in this 278 // case, do it. 279 if (WarnOnDeclarations && PDecl->isForwardDecl()) 280 Diag(ProtocolId[i].second, diag::warn_undef_protocolref) 281 << ProtocolId[i].first; 282 Protocols.push_back(PDecl); 283 } 284} 285 286/// DiagnosePropertyMismatch - Compares two properties for their 287/// attributes and types and warns on a variety of inconsistencies. 288/// 289void 290Sema::DiagnosePropertyMismatch(ObjCPropertyDecl *Property, 291 ObjCPropertyDecl *SuperProperty, 292 const IdentifierInfo *inheritedName) { 293 ObjCPropertyDecl::PropertyAttributeKind CAttr = 294 Property->getPropertyAttributes(); 295 ObjCPropertyDecl::PropertyAttributeKind SAttr = 296 SuperProperty->getPropertyAttributes(); 297 if ((CAttr & ObjCPropertyDecl::OBJC_PR_readonly) 298 && (SAttr & ObjCPropertyDecl::OBJC_PR_readwrite)) 299 Diag(Property->getLocation(), diag::warn_readonly_property) 300 << Property->getDeclName() << inheritedName; 301 if ((CAttr & ObjCPropertyDecl::OBJC_PR_copy) 302 != (SAttr & ObjCPropertyDecl::OBJC_PR_copy)) 303 Diag(Property->getLocation(), diag::warn_property_attribute) 304 << Property->getDeclName() << "copy" << inheritedName; 305 else if ((CAttr & ObjCPropertyDecl::OBJC_PR_retain) 306 != (SAttr & ObjCPropertyDecl::OBJC_PR_retain)) 307 Diag(Property->getLocation(), diag::warn_property_attribute) 308 << Property->getDeclName() << "retain" << inheritedName; 309 310 if ((CAttr & ObjCPropertyDecl::OBJC_PR_nonatomic) 311 != (SAttr & ObjCPropertyDecl::OBJC_PR_nonatomic)) 312 Diag(Property->getLocation(), diag::warn_property_attribute) 313 << Property->getDeclName() << "atomic" << inheritedName; 314 if (Property->getSetterName() != SuperProperty->getSetterName()) 315 Diag(Property->getLocation(), diag::warn_property_attribute) 316 << Property->getDeclName() << "setter" << inheritedName; 317 if (Property->getGetterName() != SuperProperty->getGetterName()) 318 Diag(Property->getLocation(), diag::warn_property_attribute) 319 << Property->getDeclName() << "getter" << inheritedName; 320 321 if (Context.getCanonicalType(Property->getType()) != 322 Context.getCanonicalType(SuperProperty->getType())) 323 Diag(Property->getLocation(), diag::warn_property_type) 324 << Property->getType() << inheritedName; 325 326} 327 328/// ComparePropertiesInBaseAndSuper - This routine compares property 329/// declarations in base and its super class, if any, and issues 330/// diagnostics in a variety of inconsistant situations. 331/// 332void Sema::ComparePropertiesInBaseAndSuper(ObjCInterfaceDecl *IDecl) { 333 ObjCInterfaceDecl *SDecl = IDecl->getSuperClass(); 334 if (!SDecl) 335 return; 336 // FIXME: O(N^2) 337 for (ObjCInterfaceDecl::prop_iterator S = SDecl->prop_begin(), 338 E = SDecl->prop_end(); S != E; ++S) { 339 ObjCPropertyDecl *SuperPDecl = (*S); 340 // Does property in super class has declaration in current class? 341 for (ObjCInterfaceDecl::prop_iterator I = IDecl->prop_begin(), 342 E = IDecl->prop_end(); I != E; ++I) { 343 ObjCPropertyDecl *PDecl = (*I); 344 if (SuperPDecl->getIdentifier() == PDecl->getIdentifier()) 345 DiagnosePropertyMismatch(PDecl, SuperPDecl, 346 SDecl->getIdentifier()); 347 } 348 } 349} 350 351/// MergeOneProtocolPropertiesIntoClass - This routine goes thru the list 352/// of properties declared in a protocol and adds them to the list 353/// of properties for current class/category if it is not there already. 354void 355Sema::MergeOneProtocolPropertiesIntoClass(Decl *CDecl, 356 ObjCProtocolDecl *PDecl) { 357 ObjCInterfaceDecl *IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(CDecl); 358 if (!IDecl) { 359 // Category 360 ObjCCategoryDecl *CatDecl = static_cast<ObjCCategoryDecl*>(CDecl); 361 assert (CatDecl && "MergeOneProtocolPropertiesIntoClass"); 362 for (ObjCProtocolDecl::prop_iterator P = PDecl->prop_begin(), 363 E = PDecl->prop_end(); P != E; ++P) { 364 ObjCPropertyDecl *Pr = (*P); 365 ObjCCategoryDecl::prop_iterator CP, CE; 366 // Is this property already in category's list of properties? 367 for (CP = CatDecl->prop_begin(), CE = CatDecl->prop_end(); 368 CP != CE; ++CP) 369 if ((*CP)->getIdentifier() == Pr->getIdentifier()) 370 break; 371 if (CP != CE) 372 // Property protocol already exist in class. Diagnose any mismatch. 373 DiagnosePropertyMismatch((*CP), Pr, PDecl->getIdentifier()); 374 } 375 return; 376 } 377 for (ObjCProtocolDecl::prop_iterator P = PDecl->prop_begin(), 378 E = PDecl->prop_end(); P != E; ++P) { 379 ObjCPropertyDecl *Pr = (*P); 380 ObjCInterfaceDecl::prop_iterator CP, CE; 381 // Is this property already in class's list of properties? 382 for (CP = IDecl->prop_begin(), CE = IDecl->prop_end(); 383 CP != CE; ++CP) 384 if ((*CP)->getIdentifier() == Pr->getIdentifier()) 385 break; 386 if (CP != CE) 387 // Property protocol already exist in class. Diagnose any mismatch. 388 DiagnosePropertyMismatch((*CP), Pr, PDecl->getIdentifier()); 389 } 390} 391 392/// MergeProtocolPropertiesIntoClass - This routine merges properties 393/// declared in 'MergeItsProtocols' objects (which can be a class or an 394/// inherited protocol into the list of properties for class/category 'CDecl' 395/// 396void Sema::MergeProtocolPropertiesIntoClass(Decl *CDecl, 397 DeclTy *MergeItsProtocols) { 398 Decl *ClassDecl = static_cast<Decl *>(MergeItsProtocols); 399 ObjCInterfaceDecl *IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(CDecl); 400 401 if (!IDecl) { 402 // Category 403 ObjCCategoryDecl *CatDecl = static_cast<ObjCCategoryDecl*>(CDecl); 404 assert (CatDecl && "MergeProtocolPropertiesIntoClass"); 405 if (ObjCCategoryDecl *MDecl = dyn_cast<ObjCCategoryDecl>(ClassDecl)) { 406 for (ObjCCategoryDecl::protocol_iterator P = MDecl->protocol_begin(), 407 E = MDecl->protocol_end(); P != E; ++P) 408 // Merge properties of category (*P) into IDECL's 409 MergeOneProtocolPropertiesIntoClass(CatDecl, *P); 410 411 // Go thru the list of protocols for this category and recursively merge 412 // their properties into this class as well. 413 for (ObjCCategoryDecl::protocol_iterator P = CatDecl->protocol_begin(), 414 E = CatDecl->protocol_end(); P != E; ++P) 415 MergeProtocolPropertiesIntoClass(CatDecl, *P); 416 } else { 417 ObjCProtocolDecl *MD = cast<ObjCProtocolDecl>(ClassDecl); 418 for (ObjCProtocolDecl::protocol_iterator P = MD->protocol_begin(), 419 E = MD->protocol_end(); P != E; ++P) 420 MergeOneProtocolPropertiesIntoClass(CatDecl, (*P)); 421 } 422 return; 423 } 424 425 if (ObjCInterfaceDecl *MDecl = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) { 426 for (ObjCInterfaceDecl::protocol_iterator P = MDecl->protocol_begin(), 427 E = MDecl->protocol_end(); P != E; ++P) 428 // Merge properties of class (*P) into IDECL's 429 MergeOneProtocolPropertiesIntoClass(IDecl, *P); 430 431 // Go thru the list of protocols for this class and recursively merge 432 // their properties into this class as well. 433 for (ObjCInterfaceDecl::protocol_iterator P = IDecl->protocol_begin(), 434 E = IDecl->protocol_end(); P != E; ++P) 435 MergeProtocolPropertiesIntoClass(IDecl, *P); 436 } else { 437 ObjCProtocolDecl *MD = cast<ObjCProtocolDecl>(ClassDecl); 438 for (ObjCProtocolDecl::protocol_iterator P = MD->protocol_begin(), 439 E = MD->protocol_end(); P != E; ++P) 440 MergeOneProtocolPropertiesIntoClass(IDecl, (*P)); 441 } 442} 443 444/// ActOnForwardProtocolDeclaration - 445Action::DeclTy * 446Sema::ActOnForwardProtocolDeclaration(SourceLocation AtProtocolLoc, 447 const IdentifierLocPair *IdentList, 448 unsigned NumElts, 449 AttributeList *attrList) { 450 llvm::SmallVector<ObjCProtocolDecl*, 32> Protocols; 451 452 for (unsigned i = 0; i != NumElts; ++i) { 453 IdentifierInfo *Ident = IdentList[i].first; 454 ObjCProtocolDecl *&PDecl = ObjCProtocols[Ident]; 455 if (PDecl == 0) { // Not already seen? 456 PDecl = ObjCProtocolDecl::Create(Context, CurContext, 457 IdentList[i].second, Ident); 458 // FIXME: PushOnScopeChains? 459 CurContext->addDecl(PDecl); 460 } 461 if (attrList) 462 ProcessDeclAttributeList(PDecl, attrList); 463 Protocols.push_back(PDecl); 464 } 465 466 ObjCForwardProtocolDecl *PDecl = 467 ObjCForwardProtocolDecl::Create(Context, CurContext, AtProtocolLoc, 468 &Protocols[0], Protocols.size()); 469 CurContext->addDecl(PDecl); 470 CheckObjCDeclScope(PDecl); 471 return PDecl; 472} 473 474Sema::DeclTy *Sema:: 475ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc, 476 IdentifierInfo *ClassName, SourceLocation ClassLoc, 477 IdentifierInfo *CategoryName, 478 SourceLocation CategoryLoc, 479 DeclTy * const *ProtoRefs, 480 unsigned NumProtoRefs, 481 SourceLocation EndProtoLoc) { 482 ObjCCategoryDecl *CDecl = 483 ObjCCategoryDecl::Create(Context, CurContext, AtInterfaceLoc, CategoryName); 484 // FIXME: PushOnScopeChains? 485 CurContext->addDecl(CDecl); 486 487 ObjCInterfaceDecl *IDecl = getObjCInterfaceDecl(ClassName); 488 /// Check that class of this category is already completely declared. 489 if (!IDecl || IDecl->isForwardDecl()) { 490 CDecl->setInvalidDecl(); 491 Diag(ClassLoc, diag::err_undef_interface) << ClassName; 492 return CDecl; 493 } 494 495 CDecl->setClassInterface(IDecl); 496 497 // If the interface is deprecated, warn about it. 498 (void)DiagnoseUseOfDecl(IDecl, ClassLoc); 499 500 /// Check for duplicate interface declaration for this category 501 ObjCCategoryDecl *CDeclChain; 502 for (CDeclChain = IDecl->getCategoryList(); CDeclChain; 503 CDeclChain = CDeclChain->getNextClassCategory()) { 504 if (CategoryName && CDeclChain->getIdentifier() == CategoryName) { 505 Diag(CategoryLoc, diag::warn_dup_category_def) 506 << ClassName << CategoryName; 507 Diag(CDeclChain->getLocation(), diag::note_previous_definition); 508 break; 509 } 510 } 511 if (!CDeclChain) 512 CDecl->insertNextClassCategory(); 513 514 if (NumProtoRefs) { 515 CDecl->setProtocolList((ObjCProtocolDecl**)ProtoRefs, NumProtoRefs,Context); 516 CDecl->setLocEnd(EndProtoLoc); 517 } 518 519 CheckObjCDeclScope(CDecl); 520 return CDecl; 521} 522 523/// ActOnStartCategoryImplementation - Perform semantic checks on the 524/// category implementation declaration and build an ObjCCategoryImplDecl 525/// object. 526Sema::DeclTy *Sema::ActOnStartCategoryImplementation( 527 SourceLocation AtCatImplLoc, 528 IdentifierInfo *ClassName, SourceLocation ClassLoc, 529 IdentifierInfo *CatName, SourceLocation CatLoc) { 530 ObjCInterfaceDecl *IDecl = getObjCInterfaceDecl(ClassName); 531 ObjCCategoryImplDecl *CDecl = 532 ObjCCategoryImplDecl::Create(Context, CurContext, AtCatImplLoc, CatName, 533 IDecl); 534 /// Check that class of this category is already completely declared. 535 if (!IDecl || IDecl->isForwardDecl()) 536 Diag(ClassLoc, diag::err_undef_interface) << ClassName; 537 538 // FIXME: PushOnScopeChains? 539 CurContext->addDecl(CDecl); 540 541 /// TODO: Check that CatName, category name, is not used in another 542 // implementation. 543 ObjCCategoryImpls.push_back(CDecl); 544 545 CheckObjCDeclScope(CDecl); 546 return CDecl; 547} 548 549Sema::DeclTy *Sema::ActOnStartClassImplementation( 550 SourceLocation AtClassImplLoc, 551 IdentifierInfo *ClassName, SourceLocation ClassLoc, 552 IdentifierInfo *SuperClassname, 553 SourceLocation SuperClassLoc) { 554 ObjCInterfaceDecl* IDecl = 0; 555 // Check for another declaration kind with the same name. 556 NamedDecl *PrevDecl = LookupName(TUScope, ClassName, LookupOrdinaryName); 557 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) { 558 Diag(ClassLoc, diag::err_redefinition_different_kind) << ClassName; 559 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 560 } else { 561 // Is there an interface declaration of this class; if not, warn! 562 IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl); 563 if (!IDecl) 564 Diag(ClassLoc, diag::warn_undef_interface) << ClassName; 565 } 566 567 // Check that super class name is valid class name 568 ObjCInterfaceDecl* SDecl = 0; 569 if (SuperClassname) { 570 // Check if a different kind of symbol declared in this scope. 571 PrevDecl = LookupName(TUScope, SuperClassname, LookupOrdinaryName); 572 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) { 573 Diag(SuperClassLoc, diag::err_redefinition_different_kind) 574 << SuperClassname; 575 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 576 } else { 577 SDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl); 578 if (!SDecl) 579 Diag(SuperClassLoc, diag::err_undef_superclass) 580 << SuperClassname << ClassName; 581 else if (IDecl && IDecl->getSuperClass() != SDecl) { 582 // This implementation and its interface do not have the same 583 // super class. 584 Diag(SuperClassLoc, diag::err_conflicting_super_class) 585 << SDecl->getDeclName(); 586 Diag(SDecl->getLocation(), diag::note_previous_definition); 587 } 588 } 589 } 590 591 if (!IDecl) { 592 // Legacy case of @implementation with no corresponding @interface. 593 // Build, chain & install the interface decl into the identifier. 594 595 // FIXME: Do we support attributes on the @implementation? If so 596 // we should copy them over. 597 IDecl = ObjCInterfaceDecl::Create(Context, CurContext, AtClassImplLoc, 598 ClassName, ClassLoc, false, true); 599 ObjCInterfaceDecls[ClassName] = IDecl; 600 IDecl->setSuperClass(SDecl); 601 IDecl->setLocEnd(ClassLoc); 602 603 // FIXME: PushOnScopeChains? 604 CurContext->addDecl(IDecl); 605 // Remember that this needs to be removed when the scope is popped. 606 TUScope->AddDecl(IDecl); 607 } 608 609 ObjCImplementationDecl* IMPDecl = 610 ObjCImplementationDecl::Create(Context, CurContext, AtClassImplLoc, 611 IDecl, SDecl); 612 613 // FIXME: PushOnScopeChains? 614 CurContext->addDecl(IMPDecl); 615 616 if (CheckObjCDeclScope(IMPDecl)) 617 return IMPDecl; 618 619 // Check that there is no duplicate implementation of this class. 620 if (ObjCImplementations[ClassName]) 621 // FIXME: Don't leak everything! 622 Diag(ClassLoc, diag::err_dup_implementation_class) << ClassName; 623 else // add it to the list. 624 ObjCImplementations[ClassName] = IMPDecl; 625 return IMPDecl; 626} 627 628void Sema::CheckImplementationIvars(ObjCImplementationDecl *ImpDecl, 629 ObjCIvarDecl **ivars, unsigned numIvars, 630 SourceLocation RBrace) { 631 assert(ImpDecl && "missing implementation decl"); 632 ObjCInterfaceDecl* IDecl = ImpDecl->getClassInterface(); 633 if (!IDecl) 634 return; 635 /// Check case of non-existing @interface decl. 636 /// (legacy objective-c @implementation decl without an @interface decl). 637 /// Add implementations's ivar to the synthesize class's ivar list. 638 if (IDecl->ImplicitInterfaceDecl()) { 639 IDecl->setIVarList(ivars, numIvars, Context); 640 IDecl->setLocEnd(RBrace); 641 return; 642 } 643 // If implementation has empty ivar list, just return. 644 if (numIvars == 0) 645 return; 646 647 assert(ivars && "missing @implementation ivars"); 648 649 // Check interface's Ivar list against those in the implementation. 650 // names and types must match. 651 // 652 unsigned j = 0; 653 ObjCInterfaceDecl::ivar_iterator 654 IVI = IDecl->ivar_begin(), IVE = IDecl->ivar_end(); 655 for (; numIvars > 0 && IVI != IVE; ++IVI) { 656 ObjCIvarDecl* ImplIvar = ivars[j++]; 657 ObjCIvarDecl* ClsIvar = *IVI; 658 assert (ImplIvar && "missing implementation ivar"); 659 assert (ClsIvar && "missing class ivar"); 660 if (Context.getCanonicalType(ImplIvar->getType()) != 661 Context.getCanonicalType(ClsIvar->getType())) { 662 Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_type) 663 << ImplIvar->getIdentifier() 664 << ImplIvar->getType() << ClsIvar->getType(); 665 Diag(ClsIvar->getLocation(), diag::note_previous_definition); 666 } 667 // TODO: Two mismatched (unequal width) Ivar bitfields should be diagnosed 668 // as error. 669 else if (ImplIvar->getIdentifier() != ClsIvar->getIdentifier()) { 670 Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_name) 671 << ImplIvar->getIdentifier() << ClsIvar->getIdentifier(); 672 Diag(ClsIvar->getLocation(), diag::note_previous_definition); 673 return; 674 } 675 --numIvars; 676 } 677 678 if (numIvars > 0) 679 Diag(ivars[j]->getLocation(), diag::err_inconsistant_ivar_count); 680 else if (IVI != IVE) 681 Diag((*IVI)->getLocation(), diag::err_inconsistant_ivar_count); 682} 683 684void Sema::WarnUndefinedMethod(SourceLocation ImpLoc, ObjCMethodDecl *method, 685 bool &IncompleteImpl) { 686 if (!IncompleteImpl) { 687 Diag(ImpLoc, diag::warn_incomplete_impl); 688 IncompleteImpl = true; 689 } 690 Diag(ImpLoc, diag::warn_undef_method_impl) << method->getDeclName(); 691} 692 693void Sema::WarnConflictingTypedMethods(ObjCMethodDecl *ImpMethodDecl, 694 ObjCMethodDecl *IntfMethodDecl) { 695 bool err = false; 696 QualType ImpMethodQType = 697 Context.getCanonicalType(ImpMethodDecl->getResultType()); 698 QualType IntfMethodQType = 699 Context.getCanonicalType(IntfMethodDecl->getResultType()); 700 if (!Context.typesAreCompatible(IntfMethodQType, ImpMethodQType)) 701 err = true; 702 else for (ObjCMethodDecl::param_iterator IM=ImpMethodDecl->param_begin(), 703 IF=IntfMethodDecl->param_begin(), 704 EM=ImpMethodDecl->param_end(); IM!=EM; ++IM, IF++) { 705 ImpMethodQType = Context.getCanonicalType((*IM)->getType()); 706 IntfMethodQType = Context.getCanonicalType((*IF)->getType()); 707 if (!Context.typesAreCompatible(IntfMethodQType, ImpMethodQType)) { 708 err = true; 709 break; 710 } 711 } 712 if (err) { 713 Diag(ImpMethodDecl->getLocation(), diag::warn_conflicting_types) 714 << ImpMethodDecl->getDeclName(); 715 Diag(IntfMethodDecl->getLocation(), diag::note_previous_definition); 716 } 717} 718 719/// isPropertyReadonly - Return true if property is readonly, by searching 720/// for the property in the class and in its categories and implementations 721/// 722bool Sema::isPropertyReadonly(ObjCPropertyDecl *PDecl, 723 ObjCInterfaceDecl *IDecl) { 724 // by far the most common case. 725 if (!PDecl->isReadOnly()) 726 return false; 727 // Even if property is ready only, if interface has a user defined setter, 728 // it is not considered read only. 729 if (IDecl->getInstanceMethod(PDecl->getSetterName())) 730 return false; 731 732 // Main class has the property as 'readonly'. Must search 733 // through the category list to see if the property's 734 // attribute has been over-ridden to 'readwrite'. 735 for (ObjCCategoryDecl *Category = IDecl->getCategoryList(); 736 Category; Category = Category->getNextClassCategory()) { 737 // Even if property is ready only, if a category has a user defined setter, 738 // it is not considered read only. 739 if (Category->getInstanceMethod(PDecl->getSetterName())) 740 return false; 741 ObjCPropertyDecl *P = 742 Category->FindPropertyDeclaration(PDecl->getIdentifier()); 743 if (P && !P->isReadOnly()) 744 return false; 745 } 746 747 // Also, check for definition of a setter method in the implementation if 748 // all else failed. 749 if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(CurContext)) { 750 if (ObjCImplementationDecl *IMD = 751 dyn_cast<ObjCImplementationDecl>(OMD->getDeclContext())) { 752 if (IMD->getInstanceMethod(PDecl->getSetterName())) 753 return false; 754 } 755 else if (ObjCCategoryImplDecl *CIMD = 756 dyn_cast<ObjCCategoryImplDecl>(OMD->getDeclContext())) { 757 if (CIMD->getInstanceMethod(PDecl->getSetterName())) 758 return false; 759 } 760 } 761 // Lastly, look through the implementation (if one is in scope). 762 if (ObjCImplementationDecl *ImpDecl = 763 ObjCImplementations[IDecl->getIdentifier()]) 764 if (ImpDecl->getInstanceMethod(PDecl->getSetterName())) 765 return false; 766 return true; 767} 768 769/// FIXME: Type hierarchies in Objective-C can be deep. We could most 770/// likely improve the efficiency of selector lookups and type 771/// checking by associating with each protocol / interface / category 772/// the flattened instance tables. If we used an immutable set to keep 773/// the table then it wouldn't add significant memory cost and it 774/// would be handy for lookups. 775 776/// CheckProtocolMethodDefs - This routine checks unimplemented methods 777/// Declared in protocol, and those referenced by it. 778void Sema::CheckProtocolMethodDefs(SourceLocation ImpLoc, 779 ObjCProtocolDecl *PDecl, 780 bool& IncompleteImpl, 781 const llvm::DenseSet<Selector> &InsMap, 782 const llvm::DenseSet<Selector> &ClsMap, 783 ObjCInterfaceDecl *IDecl) { 784 ObjCInterfaceDecl *Super = IDecl->getSuperClass(); 785 786 // If a method lookup fails locally we still need to look and see if 787 // the method was implemented by a base class or an inherited 788 // protocol. This lookup is slow, but occurs rarely in correct code 789 // and otherwise would terminate in a warning. 790 791 // check unimplemented instance methods. 792 for (ObjCProtocolDecl::instmeth_iterator I = PDecl->instmeth_begin(), 793 E = PDecl->instmeth_end(); I != E; ++I) { 794 ObjCMethodDecl *method = *I; 795 if (method->getImplementationControl() != ObjCMethodDecl::Optional && 796 !method->isSynthesized() && !InsMap.count(method->getSelector()) && 797 (!Super || !Super->lookupInstanceMethod(method->getSelector()))) 798 WarnUndefinedMethod(ImpLoc, method, IncompleteImpl); 799 } 800 // check unimplemented class methods 801 for (ObjCProtocolDecl::classmeth_iterator I = PDecl->classmeth_begin(), 802 E = PDecl->classmeth_end(); I != E; ++I) { 803 ObjCMethodDecl *method = *I; 804 if (method->getImplementationControl() != ObjCMethodDecl::Optional && 805 !ClsMap.count(method->getSelector()) && 806 (!Super || !Super->lookupClassMethod(method->getSelector()))) 807 WarnUndefinedMethod(ImpLoc, method, IncompleteImpl); 808 } 809 // Check on this protocols's referenced protocols, recursively. 810 for (ObjCProtocolDecl::protocol_iterator PI = PDecl->protocol_begin(), 811 E = PDecl->protocol_end(); PI != E; ++PI) 812 CheckProtocolMethodDefs(ImpLoc, *PI, IncompleteImpl, InsMap, ClsMap, IDecl); 813} 814 815void Sema::ImplMethodsVsClassMethods(ObjCImplementationDecl* IMPDecl, 816 ObjCInterfaceDecl* IDecl) { 817 llvm::DenseSet<Selector> InsMap; 818 // Check and see if instance methods in class interface have been 819 // implemented in the implementation class. 820 for (ObjCImplementationDecl::instmeth_iterator I = IMPDecl->instmeth_begin(), 821 E = IMPDecl->instmeth_end(); I != E; ++I) 822 InsMap.insert((*I)->getSelector()); 823 824 bool IncompleteImpl = false; 825 for (ObjCInterfaceDecl::instmeth_iterator I = IDecl->instmeth_begin(), 826 E = IDecl->instmeth_end(); I != E; ++I) { 827 if (!(*I)->isSynthesized() && !InsMap.count((*I)->getSelector())) { 828 WarnUndefinedMethod(IMPDecl->getLocation(), *I, IncompleteImpl); 829 continue; 830 } 831 832 ObjCMethodDecl *ImpMethodDecl = 833 IMPDecl->getInstanceMethod((*I)->getSelector()); 834 ObjCMethodDecl *IntfMethodDecl = 835 IDecl->getInstanceMethod((*I)->getSelector()); 836 assert(IntfMethodDecl && 837 "IntfMethodDecl is null in ImplMethodsVsClassMethods"); 838 // ImpMethodDecl may be null as in a @dynamic property. 839 if (ImpMethodDecl) 840 WarnConflictingTypedMethods(ImpMethodDecl, IntfMethodDecl); 841 } 842 843 llvm::DenseSet<Selector> ClsMap; 844 // Check and see if class methods in class interface have been 845 // implemented in the implementation class. 846 for (ObjCImplementationDecl::classmeth_iterator I =IMPDecl->classmeth_begin(), 847 E = IMPDecl->classmeth_end(); I != E; ++I) 848 ClsMap.insert((*I)->getSelector()); 849 850 for (ObjCInterfaceDecl::classmeth_iterator I = IDecl->classmeth_begin(), 851 E = IDecl->classmeth_end(); I != E; ++I) 852 if (!ClsMap.count((*I)->getSelector())) 853 WarnUndefinedMethod(IMPDecl->getLocation(), *I, IncompleteImpl); 854 else { 855 ObjCMethodDecl *ImpMethodDecl = 856 IMPDecl->getClassMethod((*I)->getSelector()); 857 ObjCMethodDecl *IntfMethodDecl = 858 IDecl->getClassMethod((*I)->getSelector()); 859 WarnConflictingTypedMethods(ImpMethodDecl, IntfMethodDecl); 860 } 861 862 863 // Check the protocol list for unimplemented methods in the @implementation 864 // class. 865 const ObjCList<ObjCProtocolDecl> &Protocols = 866 IDecl->getReferencedProtocols(); 867 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 868 E = Protocols.end(); I != E; ++I) 869 CheckProtocolMethodDefs(IMPDecl->getLocation(), *I, 870 IncompleteImpl, InsMap, ClsMap, IDecl); 871} 872 873/// ImplCategoryMethodsVsIntfMethods - Checks that methods declared in the 874/// category interface are implemented in the category @implementation. 875void Sema::ImplCategoryMethodsVsIntfMethods(ObjCCategoryImplDecl *CatImplDecl, 876 ObjCCategoryDecl *CatClassDecl) { 877 llvm::DenseSet<Selector> InsMap; 878 // Check and see if instance methods in category interface have been 879 // implemented in its implementation class. 880 for (ObjCCategoryImplDecl::instmeth_iterator I =CatImplDecl->instmeth_begin(), 881 E = CatImplDecl->instmeth_end(); I != E; ++I) 882 InsMap.insert((*I)->getSelector()); 883 884 bool IncompleteImpl = false; 885 for (ObjCCategoryDecl::instmeth_iterator I = CatClassDecl->instmeth_begin(), 886 E = CatClassDecl->instmeth_end(); I != E; ++I) 887 if (!(*I)->isSynthesized() && !InsMap.count((*I)->getSelector())) 888 WarnUndefinedMethod(CatImplDecl->getLocation(), *I, IncompleteImpl); 889 else { 890 ObjCMethodDecl *ImpMethodDecl = 891 CatImplDecl->getInstanceMethod((*I)->getSelector()); 892 ObjCMethodDecl *IntfMethodDecl = 893 CatClassDecl->getInstanceMethod((*I)->getSelector()); 894 assert(IntfMethodDecl && 895 "IntfMethodDecl is null in ImplCategoryMethodsVsIntfMethods"); 896 // ImpMethodDecl may be null as in a @dynamic property. 897 if (ImpMethodDecl) 898 WarnConflictingTypedMethods(ImpMethodDecl, IntfMethodDecl); 899 } 900 901 llvm::DenseSet<Selector> ClsMap; 902 // Check and see if class methods in category interface have been 903 // implemented in its implementation class. 904 for (ObjCCategoryImplDecl::classmeth_iterator 905 I = CatImplDecl->classmeth_begin(), E = CatImplDecl->classmeth_end(); 906 I != E; ++I) 907 ClsMap.insert((*I)->getSelector()); 908 909 for (ObjCCategoryDecl::classmeth_iterator I = CatClassDecl->classmeth_begin(), 910 E = CatClassDecl->classmeth_end(); I != E; ++I) 911 if (!ClsMap.count((*I)->getSelector())) 912 WarnUndefinedMethod(CatImplDecl->getLocation(), *I, IncompleteImpl); 913 else { 914 ObjCMethodDecl *ImpMethodDecl = 915 CatImplDecl->getClassMethod((*I)->getSelector()); 916 ObjCMethodDecl *IntfMethodDecl = 917 CatClassDecl->getClassMethod((*I)->getSelector()); 918 WarnConflictingTypedMethods(ImpMethodDecl, IntfMethodDecl); 919 } 920 // Check the protocol list for unimplemented methods in the @implementation 921 // class. 922 for (ObjCCategoryDecl::protocol_iterator PI = CatClassDecl->protocol_begin(), 923 E = CatClassDecl->protocol_end(); PI != E; ++PI) 924 CheckProtocolMethodDefs(CatImplDecl->getLocation(), *PI, IncompleteImpl, 925 InsMap, ClsMap, CatClassDecl->getClassInterface()); 926} 927 928/// ActOnForwardClassDeclaration - 929Action::DeclTy * 930Sema::ActOnForwardClassDeclaration(SourceLocation AtClassLoc, 931 IdentifierInfo **IdentList, 932 unsigned NumElts) { 933 llvm::SmallVector<ObjCInterfaceDecl*, 32> Interfaces; 934 935 for (unsigned i = 0; i != NumElts; ++i) { 936 // Check for another declaration kind with the same name. 937 NamedDecl *PrevDecl = LookupName(TUScope, IdentList[i], LookupOrdinaryName); 938 if (PrevDecl && PrevDecl->isTemplateParameter()) { 939 // Maybe we will complain about the shadowed template parameter. 940 DiagnoseTemplateParameterShadow(AtClassLoc, PrevDecl); 941 // Just pretend that we didn't see the previous declaration. 942 PrevDecl = 0; 943 } 944 945 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) { 946 // GCC apparently allows the following idiom: 947 // 948 // typedef NSObject < XCElementTogglerP > XCElementToggler; 949 // @class XCElementToggler; 950 // 951 // FIXME: Make an extension? 952 TypedefDecl *TDD = dyn_cast<TypedefDecl>(PrevDecl); 953 if (!TDD || !isa<ObjCInterfaceType>(TDD->getUnderlyingType())) { 954 Diag(AtClassLoc, diag::err_redefinition_different_kind) << IdentList[i]; 955 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 956 } 957 } 958 ObjCInterfaceDecl *IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl); 959 if (!IDecl) { // Not already seen? Make a forward decl. 960 IDecl = ObjCInterfaceDecl::Create(Context, CurContext, AtClassLoc, 961 IdentList[i], SourceLocation(), true); 962 ObjCInterfaceDecls[IdentList[i]] = IDecl; 963 964 // FIXME: PushOnScopeChains? 965 CurContext->addDecl(IDecl); 966 // Remember that this needs to be removed when the scope is popped. 967 TUScope->AddDecl(IDecl); 968 } 969 970 Interfaces.push_back(IDecl); 971 } 972 973 ObjCClassDecl *CDecl = ObjCClassDecl::Create(Context, CurContext, AtClassLoc, 974 &Interfaces[0], 975 Interfaces.size()); 976 CurContext->addDecl(CDecl); 977 CheckObjCDeclScope(CDecl); 978 return CDecl; 979} 980 981 982/// MatchTwoMethodDeclarations - Checks that two methods have matching type and 983/// returns true, or false, accordingly. 984/// TODO: Handle protocol list; such as id<p1,p2> in type comparisons 985bool Sema::MatchTwoMethodDeclarations(const ObjCMethodDecl *Method, 986 const ObjCMethodDecl *PrevMethod, 987 bool matchBasedOnSizeAndAlignment) { 988 QualType T1 = Context.getCanonicalType(Method->getResultType()); 989 QualType T2 = Context.getCanonicalType(PrevMethod->getResultType()); 990 991 if (T1 != T2) { 992 // The result types are different. 993 if (!matchBasedOnSizeAndAlignment) 994 return false; 995 // Incomplete types don't have a size and alignment. 996 if (T1->isIncompleteType() || T2->isIncompleteType()) 997 return false; 998 // Check is based on size and alignment. 999 if (Context.getTypeInfo(T1) != Context.getTypeInfo(T2)) 1000 return false; 1001 } 1002 1003 ObjCMethodDecl::param_iterator ParamI = Method->param_begin(), 1004 E = Method->param_end(); 1005 ObjCMethodDecl::param_iterator PrevI = PrevMethod->param_begin(); 1006 1007 for (; ParamI != E; ++ParamI, ++PrevI) { 1008 assert(PrevI != PrevMethod->param_end() && "Param mismatch"); 1009 T1 = Context.getCanonicalType((*ParamI)->getType()); 1010 T2 = Context.getCanonicalType((*PrevI)->getType()); 1011 if (T1 != T2) { 1012 // The result types are different. 1013 if (!matchBasedOnSizeAndAlignment) 1014 return false; 1015 // Incomplete types don't have a size and alignment. 1016 if (T1->isIncompleteType() || T2->isIncompleteType()) 1017 return false; 1018 // Check is based on size and alignment. 1019 if (Context.getTypeInfo(T1) != Context.getTypeInfo(T2)) 1020 return false; 1021 } 1022 } 1023 return true; 1024} 1025 1026void Sema::AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method) { 1027 ObjCMethodList &FirstMethod = InstanceMethodPool[Method->getSelector()]; 1028 if (!FirstMethod.Method) { 1029 // Haven't seen a method with this selector name yet - add it. 1030 FirstMethod.Method = Method; 1031 FirstMethod.Next = 0; 1032 } else { 1033 // We've seen a method with this name, now check the type signature(s). 1034 bool match = MatchTwoMethodDeclarations(Method, FirstMethod.Method); 1035 1036 for (ObjCMethodList *Next = FirstMethod.Next; !match && Next; 1037 Next = Next->Next) 1038 match = MatchTwoMethodDeclarations(Method, Next->Method); 1039 1040 if (!match) { 1041 // We have a new signature for an existing method - add it. 1042 // This is extremely rare. Only 1% of Cocoa selectors are "overloaded". 1043 FirstMethod.Next = new ObjCMethodList(Method, FirstMethod.Next);; 1044 } 1045 } 1046} 1047 1048// FIXME: Finish implementing -Wno-strict-selector-match. 1049ObjCMethodDecl *Sema::LookupInstanceMethodInGlobalPool(Selector Sel, 1050 SourceRange R) { 1051 ObjCMethodList &MethList = InstanceMethodPool[Sel]; 1052 bool issueWarning = false; 1053 1054 if (MethList.Method && MethList.Next) { 1055 for (ObjCMethodList *Next = MethList.Next; Next; Next = Next->Next) 1056 // This checks if the methods differ by size & alignment. 1057 if (!MatchTwoMethodDeclarations(MethList.Method, Next->Method, true)) 1058 issueWarning = true; 1059 } 1060 if (issueWarning && (MethList.Method && MethList.Next)) { 1061 Diag(R.getBegin(), diag::warn_multiple_method_decl) << Sel << R; 1062 Diag(MethList.Method->getLocStart(), diag::note_using_decl) 1063 << MethList.Method->getSourceRange(); 1064 for (ObjCMethodList *Next = MethList.Next; Next; Next = Next->Next) 1065 Diag(Next->Method->getLocStart(), diag::note_also_found_decl) 1066 << Next->Method->getSourceRange(); 1067 } 1068 return MethList.Method; 1069} 1070 1071void Sema::AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method) { 1072 ObjCMethodList &FirstMethod = FactoryMethodPool[Method->getSelector()]; 1073 if (!FirstMethod.Method) { 1074 // Haven't seen a method with this selector name yet - add it. 1075 FirstMethod.Method = Method; 1076 FirstMethod.Next = 0; 1077 } else { 1078 // We've seen a method with this name, now check the type signature(s). 1079 bool match = MatchTwoMethodDeclarations(Method, FirstMethod.Method); 1080 1081 for (ObjCMethodList *Next = FirstMethod.Next; !match && Next; 1082 Next = Next->Next) 1083 match = MatchTwoMethodDeclarations(Method, Next->Method); 1084 1085 if (!match) { 1086 // We have a new signature for an existing method - add it. 1087 // This is extremely rare. Only 1% of Cocoa selectors are "overloaded". 1088 struct ObjCMethodList *OMI = new ObjCMethodList(Method, FirstMethod.Next); 1089 FirstMethod.Next = OMI; 1090 } 1091 } 1092} 1093 1094/// ProcessPropertyDecl - Make sure that any user-defined setter/getter methods 1095/// have the property type and issue diagnostics if they don't. 1096/// Also synthesize a getter/setter method if none exist (and update the 1097/// appropriate lookup tables. FIXME: Should reconsider if adding synthesized 1098/// methods is the "right" thing to do. 1099void Sema::ProcessPropertyDecl(ObjCPropertyDecl *property, 1100 ObjCContainerDecl *CD) { 1101 ObjCMethodDecl *GetterMethod, *SetterMethod; 1102 1103 GetterMethod = CD->getInstanceMethod(property->getGetterName()); 1104 SetterMethod = CD->getInstanceMethod(property->getSetterName()); 1105 1106 if (GetterMethod && 1107 GetterMethod->getResultType() != property->getType()) { 1108 Diag(property->getLocation(), 1109 diag::err_accessor_property_type_mismatch) 1110 << property->getDeclName() 1111 << GetterMethod->getSelector().getAsIdentifierInfo(); 1112 Diag(GetterMethod->getLocation(), diag::note_declared_at); 1113 } 1114 1115 if (SetterMethod) { 1116 if (Context.getCanonicalType(SetterMethod->getResultType()) 1117 != Context.VoidTy) 1118 Diag(SetterMethod->getLocation(), diag::err_setter_type_void); 1119 if (SetterMethod->param_size() != 1 || 1120 ((*SetterMethod->param_begin())->getType() != property->getType())) { 1121 Diag(property->getLocation(), 1122 diag::err_accessor_property_type_mismatch) 1123 << property->getDeclName() 1124 << SetterMethod->getSelector().getAsIdentifierInfo(); 1125 Diag(SetterMethod->getLocation(), diag::note_declared_at); 1126 } 1127 } 1128 1129 // Synthesize getter/setter methods if none exist. 1130 // Find the default getter and if one not found, add one. 1131 // FIXME: The synthesized property we set here is misleading. We 1132 // almost always synthesize these methods unless the user explicitly 1133 // provided prototypes (which is odd, but allowed). Sema should be 1134 // typechecking that the declarations jive in that situation (which 1135 // it is not currently). 1136 if (!GetterMethod) { 1137 // No instance method of same name as property getter name was found. 1138 // Declare a getter method and add it to the list of methods 1139 // for this class. 1140 GetterMethod = ObjCMethodDecl::Create(Context, property->getLocation(), 1141 property->getLocation(), property->getGetterName(), 1142 property->getType(), CD, true, false, true, 1143 (property->getPropertyImplementation() == 1144 ObjCPropertyDecl::Optional) ? 1145 ObjCMethodDecl::Optional : 1146 ObjCMethodDecl::Required); 1147 CD->addDecl(GetterMethod); 1148 } else 1149 // A user declared getter will be synthesize when @synthesize of 1150 // the property with the same name is seen in the @implementation 1151 GetterMethod->setIsSynthesized(); 1152 property->setGetterMethodDecl(GetterMethod); 1153 1154 // Skip setter if property is read-only. 1155 if (!property->isReadOnly()) { 1156 // Find the default setter and if one not found, add one. 1157 if (!SetterMethod) { 1158 // No instance method of same name as property setter name was found. 1159 // Declare a setter method and add it to the list of methods 1160 // for this class. 1161 SetterMethod = ObjCMethodDecl::Create(Context, property->getLocation(), 1162 property->getLocation(), 1163 property->getSetterName(), 1164 Context.VoidTy, CD, true, false, true, 1165 (property->getPropertyImplementation() == 1166 ObjCPropertyDecl::Optional) ? 1167 ObjCMethodDecl::Optional : 1168 ObjCMethodDecl::Required); 1169 // Invent the arguments for the setter. We don't bother making a 1170 // nice name for the argument. 1171 ParmVarDecl *Argument = ParmVarDecl::Create(Context, SetterMethod, 1172 SourceLocation(), 1173 property->getIdentifier(), 1174 property->getType(), 1175 VarDecl::None, 1176 0); 1177 SetterMethod->setMethodParams(&Argument, 1, Context); 1178 CD->addDecl(SetterMethod); 1179 } else 1180 // A user declared setter will be synthesize when @synthesize of 1181 // the property with the same name is seen in the @implementation 1182 SetterMethod->setIsSynthesized(); 1183 property->setSetterMethodDecl(SetterMethod); 1184 } 1185 // Add any synthesized methods to the global pool. This allows us to 1186 // handle the following, which is supported by GCC (and part of the design). 1187 // 1188 // @interface Foo 1189 // @property double bar; 1190 // @end 1191 // 1192 // void thisIsUnfortunate() { 1193 // id foo; 1194 // double bar = [foo bar]; 1195 // } 1196 // 1197 if (GetterMethod) 1198 AddInstanceMethodToGlobalPool(GetterMethod); 1199 if (SetterMethod) 1200 AddInstanceMethodToGlobalPool(SetterMethod); 1201} 1202 1203// Note: For class/category implemenations, allMethods/allProperties is 1204// always null. 1205void Sema::ActOnAtEnd(SourceLocation AtEndLoc, DeclTy *classDecl, 1206 DeclTy **allMethods, unsigned allNum, 1207 DeclTy **allProperties, unsigned pNum) { 1208 Decl *ClassDecl = static_cast<Decl *>(classDecl); 1209 1210 // FIXME: If we don't have a ClassDecl, we have an error. We should consider 1211 // always passing in a decl. If the decl has an error, isInvalidDecl() 1212 // should be true. 1213 if (!ClassDecl) 1214 return; 1215 1216 bool isInterfaceDeclKind = 1217 isa<ObjCInterfaceDecl>(ClassDecl) || isa<ObjCCategoryDecl>(ClassDecl) 1218 || isa<ObjCProtocolDecl>(ClassDecl); 1219 bool checkIdenticalMethods = isa<ObjCImplementationDecl>(ClassDecl); 1220 1221 DeclContext *DC = dyn_cast<DeclContext>(ClassDecl); 1222 1223 // FIXME: Remove these and use the ObjCContainerDecl/DeclContext. 1224 llvm::DenseMap<Selector, const ObjCMethodDecl*> InsMap; 1225 llvm::DenseMap<Selector, const ObjCMethodDecl*> ClsMap; 1226 1227 for (unsigned i = 0; i < allNum; i++ ) { 1228 ObjCMethodDecl *Method = 1229 cast_or_null<ObjCMethodDecl>(static_cast<Decl*>(allMethods[i])); 1230 1231 if (!Method) continue; // Already issued a diagnostic. 1232 if (Method->isInstanceMethod()) { 1233 /// Check for instance method of the same name with incompatible types 1234 const ObjCMethodDecl *&PrevMethod = InsMap[Method->getSelector()]; 1235 bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod) 1236 : false; 1237 if ((isInterfaceDeclKind && PrevMethod && !match) 1238 || (checkIdenticalMethods && match)) { 1239 Diag(Method->getLocation(), diag::err_duplicate_method_decl) 1240 << Method->getDeclName(); 1241 Diag(PrevMethod->getLocation(), diag::note_previous_declaration); 1242 } else { 1243 DC->addDecl(Method); 1244 InsMap[Method->getSelector()] = Method; 1245 /// The following allows us to typecheck messages to "id". 1246 AddInstanceMethodToGlobalPool(Method); 1247 } 1248 } 1249 else { 1250 /// Check for class method of the same name with incompatible types 1251 const ObjCMethodDecl *&PrevMethod = ClsMap[Method->getSelector()]; 1252 bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod) 1253 : false; 1254 if ((isInterfaceDeclKind && PrevMethod && !match) 1255 || (checkIdenticalMethods && match)) { 1256 Diag(Method->getLocation(), diag::err_duplicate_method_decl) 1257 << Method->getDeclName(); 1258 Diag(PrevMethod->getLocation(), diag::note_previous_declaration); 1259 } else { 1260 DC->addDecl(Method); 1261 ClsMap[Method->getSelector()] = Method; 1262 /// The following allows us to typecheck messages to "Class". 1263 AddFactoryMethodToGlobalPool(Method); 1264 } 1265 } 1266 } 1267 if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) { 1268 // Compares properties declared in this class to those of its 1269 // super class. 1270 ComparePropertiesInBaseAndSuper(I); 1271 MergeProtocolPropertiesIntoClass(I, I); 1272 } else if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(ClassDecl)) { 1273 // Categories are used to extend the class by declaring new methods. 1274 // By the same token, they are also used to add new properties. No 1275 // need to compare the added property to those in the class. 1276 1277 // Merge protocol properties into category 1278 MergeProtocolPropertiesIntoClass(C, C); 1279 } 1280 if (ObjCContainerDecl *CDecl = dyn_cast<ObjCContainerDecl>(ClassDecl)) { 1281 // ProcessPropertyDecl is responsible for diagnosing conflicts with any 1282 // user-defined setter/getter. It also synthesizes setter/getter methods 1283 // and adds them to the DeclContext and global method pools. 1284 for (ObjCContainerDecl::prop_iterator I = CDecl->prop_begin(), 1285 E = CDecl->prop_end(); I != E; ++I) 1286 ProcessPropertyDecl(*I, CDecl); 1287 CDecl->setAtEndLoc(AtEndLoc); 1288 } 1289 if (ObjCImplementationDecl *IC=dyn_cast<ObjCImplementationDecl>(ClassDecl)) { 1290 IC->setLocEnd(AtEndLoc); 1291 if (ObjCInterfaceDecl* IDecl = IC->getClassInterface()) 1292 ImplMethodsVsClassMethods(IC, IDecl); 1293 } else if (ObjCCategoryImplDecl* CatImplClass = 1294 dyn_cast<ObjCCategoryImplDecl>(ClassDecl)) { 1295 CatImplClass->setLocEnd(AtEndLoc); 1296 1297 // Find category interface decl and then check that all methods declared 1298 // in this interface are implemented in the category @implementation. 1299 if (ObjCInterfaceDecl* IDecl = CatImplClass->getClassInterface()) { 1300 for (ObjCCategoryDecl *Categories = IDecl->getCategoryList(); 1301 Categories; Categories = Categories->getNextClassCategory()) { 1302 if (Categories->getIdentifier() == CatImplClass->getIdentifier()) { 1303 ImplCategoryMethodsVsIntfMethods(CatImplClass, Categories); 1304 break; 1305 } 1306 } 1307 } 1308 } 1309} 1310 1311 1312/// CvtQTToAstBitMask - utility routine to produce an AST bitmask for 1313/// objective-c's type qualifier from the parser version of the same info. 1314static Decl::ObjCDeclQualifier 1315CvtQTToAstBitMask(ObjCDeclSpec::ObjCDeclQualifier PQTVal) { 1316 Decl::ObjCDeclQualifier ret = Decl::OBJC_TQ_None; 1317 if (PQTVal & ObjCDeclSpec::DQ_In) 1318 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_In); 1319 if (PQTVal & ObjCDeclSpec::DQ_Inout) 1320 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Inout); 1321 if (PQTVal & ObjCDeclSpec::DQ_Out) 1322 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Out); 1323 if (PQTVal & ObjCDeclSpec::DQ_Bycopy) 1324 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Bycopy); 1325 if (PQTVal & ObjCDeclSpec::DQ_Byref) 1326 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Byref); 1327 if (PQTVal & ObjCDeclSpec::DQ_Oneway) 1328 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Oneway); 1329 1330 return ret; 1331} 1332 1333Sema::DeclTy *Sema::ActOnMethodDeclaration( 1334 SourceLocation MethodLoc, SourceLocation EndLoc, 1335 tok::TokenKind MethodType, DeclTy *classDecl, 1336 ObjCDeclSpec &ReturnQT, TypeTy *ReturnType, 1337 Selector Sel, 1338 // optional arguments. The number of types/arguments is obtained 1339 // from the Sel.getNumArgs(). 1340 ObjCDeclSpec *ArgQT, TypeTy **ArgTypes, IdentifierInfo **ArgNames, 1341 llvm::SmallVectorImpl<Declarator> &Cdecls, 1342 AttributeList *AttrList, tok::ObjCKeywordKind MethodDeclKind, 1343 bool isVariadic) { 1344 Decl *ClassDecl = static_cast<Decl*>(classDecl); 1345 1346 // Make sure we can establish a context for the method. 1347 if (!ClassDecl) { 1348 Diag(MethodLoc, diag::error_missing_method_context); 1349 return 0; 1350 } 1351 QualType resultDeclType; 1352 1353 if (ReturnType) { 1354 resultDeclType = QualType::getFromOpaquePtr(ReturnType); 1355 1356 // Methods cannot return interface types. All ObjC objects are 1357 // passed by reference. 1358 if (resultDeclType->isObjCInterfaceType()) { 1359 Diag(MethodLoc, diag::err_object_cannot_be_by_value) 1360 << "returned"; 1361 return 0; 1362 } 1363 } else // get the type for "id". 1364 resultDeclType = Context.getObjCIdType(); 1365 1366 ObjCMethodDecl* ObjCMethod = 1367 ObjCMethodDecl::Create(Context, MethodLoc, EndLoc, Sel, resultDeclType, 1368 dyn_cast<DeclContext>(ClassDecl), 1369 MethodType == tok::minus, isVariadic, 1370 false, 1371 MethodDeclKind == tok::objc_optional ? 1372 ObjCMethodDecl::Optional : 1373 ObjCMethodDecl::Required); 1374 1375 llvm::SmallVector<ParmVarDecl*, 16> Params; 1376 1377 for (unsigned i = 0; i < Sel.getNumArgs(); i++) { 1378 // FIXME: arg->AttrList must be stored too! 1379 QualType argType, originalArgType; 1380 1381 if (ArgTypes[i]) { 1382 argType = QualType::getFromOpaquePtr(ArgTypes[i]); 1383 // Perform the default array/function conversions (C99 6.7.5.3p[7,8]). 1384 if (argType->isArrayType()) { // (char *[]) -> (char **) 1385 originalArgType = argType; 1386 argType = Context.getArrayDecayedType(argType); 1387 } 1388 else if (argType->isFunctionType()) 1389 argType = Context.getPointerType(argType); 1390 else if (argType->isObjCInterfaceType()) { 1391 // FIXME! provide more precise location for the parameter 1392 Diag(MethodLoc, diag::err_object_cannot_be_by_value) 1393 << "passed"; 1394 ObjCMethod->setInvalidDecl(); 1395 return 0; 1396 } 1397 } else 1398 argType = Context.getObjCIdType(); 1399 ParmVarDecl* Param; 1400 if (originalArgType.isNull()) 1401 Param = ParmVarDecl::Create(Context, ObjCMethod, 1402 SourceLocation(/*FIXME*/), 1403 ArgNames[i], argType, 1404 VarDecl::None, 0); 1405 else 1406 Param = OriginalParmVarDecl::Create(Context, ObjCMethod, 1407 SourceLocation(/*FIXME*/), 1408 ArgNames[i], argType, originalArgType, 1409 VarDecl::None, 0); 1410 1411 Param->setObjCDeclQualifier( 1412 CvtQTToAstBitMask(ArgQT[i].getObjCDeclQualifier())); 1413 Params.push_back(Param); 1414 } 1415 1416 ObjCMethod->setMethodParams(&Params[0], Sel.getNumArgs(), Context); 1417 ObjCMethod->setObjCDeclQualifier( 1418 CvtQTToAstBitMask(ReturnQT.getObjCDeclQualifier())); 1419 const ObjCMethodDecl *PrevMethod = 0; 1420 1421 if (AttrList) 1422 ProcessDeclAttributeList(ObjCMethod, AttrList); 1423 1424 // For implementations (which can be very "coarse grain"), we add the 1425 // method now. This allows the AST to implement lookup methods that work 1426 // incrementally (without waiting until we parse the @end). It also allows 1427 // us to flag multiple declaration errors as they occur. 1428 if (ObjCImplementationDecl *ImpDecl = 1429 dyn_cast<ObjCImplementationDecl>(ClassDecl)) { 1430 if (MethodType == tok::minus) { 1431 PrevMethod = ImpDecl->getInstanceMethod(Sel); 1432 ImpDecl->addInstanceMethod(ObjCMethod); 1433 } else { 1434 PrevMethod = ImpDecl->getClassMethod(Sel); 1435 ImpDecl->addClassMethod(ObjCMethod); 1436 } 1437 } 1438 else if (ObjCCategoryImplDecl *CatImpDecl = 1439 dyn_cast<ObjCCategoryImplDecl>(ClassDecl)) { 1440 if (MethodType == tok::minus) { 1441 PrevMethod = CatImpDecl->getInstanceMethod(Sel); 1442 CatImpDecl->addInstanceMethod(ObjCMethod); 1443 } else { 1444 PrevMethod = CatImpDecl->getClassMethod(Sel); 1445 CatImpDecl->addClassMethod(ObjCMethod); 1446 } 1447 } 1448 if (PrevMethod) { 1449 // You can never have two method definitions with the same name. 1450 Diag(ObjCMethod->getLocation(), diag::err_duplicate_method_decl) 1451 << ObjCMethod->getDeclName(); 1452 Diag(PrevMethod->getLocation(), diag::note_previous_declaration); 1453 } 1454 return ObjCMethod; 1455} 1456 1457void Sema::CheckObjCPropertyAttributes(QualType PropertyTy, 1458 SourceLocation Loc, 1459 unsigned &Attributes) { 1460 // FIXME: Improve the reported location. 1461 1462 // readonly and readwrite/assign/retain/copy conflict. 1463 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) && 1464 (Attributes & (ObjCDeclSpec::DQ_PR_readwrite | 1465 ObjCDeclSpec::DQ_PR_assign | 1466 ObjCDeclSpec::DQ_PR_copy | 1467 ObjCDeclSpec::DQ_PR_retain))) { 1468 const char * which = (Attributes & ObjCDeclSpec::DQ_PR_readwrite) ? 1469 "readwrite" : 1470 (Attributes & ObjCDeclSpec::DQ_PR_assign) ? 1471 "assign" : 1472 (Attributes & ObjCDeclSpec::DQ_PR_copy) ? 1473 "copy" : "retain"; 1474 1475 Diag(Loc, (Attributes & (ObjCDeclSpec::DQ_PR_readwrite)) ? 1476 diag::err_objc_property_attr_mutually_exclusive : 1477 diag::warn_objc_property_attr_mutually_exclusive) 1478 << "readonly" << which; 1479 } 1480 1481 // Check for copy or retain on non-object types. 1482 if ((Attributes & (ObjCDeclSpec::DQ_PR_copy | ObjCDeclSpec::DQ_PR_retain)) && 1483 !Context.isObjCObjectPointerType(PropertyTy)) { 1484 Diag(Loc, diag::err_objc_property_requires_object) 1485 << (Attributes & ObjCDeclSpec::DQ_PR_copy ? "copy" : "retain"); 1486 Attributes &= ~(ObjCDeclSpec::DQ_PR_copy | ObjCDeclSpec::DQ_PR_retain); 1487 } 1488 1489 // Check for more than one of { assign, copy, retain }. 1490 if (Attributes & ObjCDeclSpec::DQ_PR_assign) { 1491 if (Attributes & ObjCDeclSpec::DQ_PR_copy) { 1492 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive) 1493 << "assign" << "copy"; 1494 Attributes &= ~ObjCDeclSpec::DQ_PR_copy; 1495 } 1496 if (Attributes & ObjCDeclSpec::DQ_PR_retain) { 1497 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive) 1498 << "assign" << "retain"; 1499 Attributes &= ~ObjCDeclSpec::DQ_PR_retain; 1500 } 1501 } else if (Attributes & ObjCDeclSpec::DQ_PR_copy) { 1502 if (Attributes & ObjCDeclSpec::DQ_PR_retain) { 1503 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive) 1504 << "copy" << "retain"; 1505 Attributes &= ~ObjCDeclSpec::DQ_PR_retain; 1506 } 1507 } 1508 1509 // Warn if user supplied no assignment attribute, property is 1510 // readwrite, and this is an object type. 1511 if (!(Attributes & (ObjCDeclSpec::DQ_PR_assign | ObjCDeclSpec::DQ_PR_copy | 1512 ObjCDeclSpec::DQ_PR_retain)) && 1513 !(Attributes & ObjCDeclSpec::DQ_PR_readonly) && 1514 Context.isObjCObjectPointerType(PropertyTy)) { 1515 // Skip this warning in gc-only mode. 1516 if (getLangOptions().getGCMode() != LangOptions::GCOnly) 1517 Diag(Loc, diag::warn_objc_property_no_assignment_attribute); 1518 1519 // If non-gc code warn that this is likely inappropriate. 1520 if (getLangOptions().getGCMode() == LangOptions::NonGC) 1521 Diag(Loc, diag::warn_objc_property_default_assign_on_object); 1522 1523 // FIXME: Implement warning dependent on NSCopying being 1524 // implemented. See also: 1525 // <rdar://5168496&4855821&5607453&5096644&4947311&5698469&4947014&5168496> 1526 // (please trim this list while you are at it). 1527 } 1528} 1529 1530Sema::DeclTy *Sema::ActOnProperty(Scope *S, SourceLocation AtLoc, 1531 FieldDeclarator &FD, 1532 ObjCDeclSpec &ODS, 1533 Selector GetterSel, 1534 Selector SetterSel, 1535 DeclTy *ClassCategory, 1536 bool *isOverridingProperty, 1537 tok::ObjCKeywordKind MethodImplKind) { 1538 unsigned Attributes = ODS.getPropertyAttributes(); 1539 bool isReadWrite = ((Attributes & ObjCDeclSpec::DQ_PR_readwrite) || 1540 // default is readwrite! 1541 !(Attributes & ObjCDeclSpec::DQ_PR_readonly)); 1542 // property is defaulted to 'assign' if it is readwrite and is 1543 // not retain or copy 1544 bool isAssign = ((Attributes & ObjCDeclSpec::DQ_PR_assign) || 1545 (isReadWrite && 1546 !(Attributes & ObjCDeclSpec::DQ_PR_retain) && 1547 !(Attributes & ObjCDeclSpec::DQ_PR_copy))); 1548 QualType T = GetTypeForDeclarator(FD.D, S); 1549 Decl *ClassDecl = static_cast<Decl *>(ClassCategory); 1550 1551 // May modify Attributes. 1552 CheckObjCPropertyAttributes(T, AtLoc, Attributes); 1553 1554 if (ObjCCategoryDecl *CDecl = dyn_cast<ObjCCategoryDecl>(ClassDecl)) 1555 if (!CDecl->getIdentifier()) { 1556 // This is an anonymous category. property requires special 1557 // handling. 1558 if (ObjCInterfaceDecl *ICDecl = CDecl->getClassInterface()) { 1559 if (ObjCPropertyDecl *PIDecl = 1560 ICDecl->FindPropertyDeclaration(FD.D.getIdentifier())) { 1561 // property 'PIDecl's readonly attribute will be over-ridden 1562 // with anonymous category's readwrite property attribute! 1563 unsigned PIkind = PIDecl->getPropertyAttributes(); 1564 if (isReadWrite && (PIkind & ObjCPropertyDecl::OBJC_PR_readonly)) { 1565 if ((Attributes & ObjCPropertyDecl::OBJC_PR_nonatomic) != 1566 (PIkind & ObjCPropertyDecl::OBJC_PR_nonatomic)) 1567 Diag(AtLoc, diag::warn_property_attr_mismatch); 1568 PIDecl->makeitReadWriteAttribute(); 1569 if (Attributes & ObjCDeclSpec::DQ_PR_retain) 1570 PIDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_retain); 1571 if (Attributes & ObjCDeclSpec::DQ_PR_copy) 1572 PIDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_copy); 1573 PIDecl->setSetterName(SetterSel); 1574 // FIXME: use a common routine with addPropertyMethods. 1575 ObjCMethodDecl *SetterDecl = 1576 ObjCMethodDecl::Create(Context, AtLoc, AtLoc, SetterSel, 1577 Context.VoidTy, 1578 ICDecl, 1579 true, false, true, 1580 ObjCMethodDecl::Required); 1581 ParmVarDecl *Argument = ParmVarDecl::Create(Context, SetterDecl, 1582 SourceLocation(), 1583 FD.D.getIdentifier(), 1584 T, VarDecl::None, 0); 1585 SetterDecl->setMethodParams(&Argument, 1, Context); 1586 PIDecl->setSetterMethodDecl(SetterDecl); 1587 } 1588 else 1589 Diag(AtLoc, diag::err_use_continuation_class) << ICDecl->getDeclName(); 1590 *isOverridingProperty = true; 1591 return 0; 1592 } 1593 // No matching property found in the main class. Just fall thru 1594 // and add property to the anonymous category. It looks like 1595 // it works as is. This category becomes just like a category 1596 // for its primary class. 1597 } else { 1598 Diag(CDecl->getLocation(), diag::err_continuation_class); 1599 *isOverridingProperty = true; 1600 return 0; 1601 } 1602 } 1603 1604 Type *t = T.getTypePtr(); 1605 if (t->isArrayType() || t->isFunctionType()) 1606 Diag(AtLoc, diag::err_property_type) << T; 1607 1608 DeclContext *DC = dyn_cast<DeclContext>(ClassDecl); 1609 assert(DC && "ClassDecl is not a DeclContext"); 1610 ObjCPropertyDecl *PDecl = ObjCPropertyDecl::Create(Context, DC, AtLoc, 1611 FD.D.getIdentifier(), T); 1612 DC->addDecl(PDecl); 1613 1614 ProcessDeclAttributes(PDecl, FD.D); 1615 1616 // Regardless of setter/getter attribute, we save the default getter/setter 1617 // selector names in anticipation of declaration of setter/getter methods. 1618 PDecl->setGetterName(GetterSel); 1619 PDecl->setSetterName(SetterSel); 1620 1621 if (Attributes & ObjCDeclSpec::DQ_PR_readonly) 1622 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readonly); 1623 1624 if (Attributes & ObjCDeclSpec::DQ_PR_getter) 1625 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_getter); 1626 1627 if (Attributes & ObjCDeclSpec::DQ_PR_setter) 1628 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_setter); 1629 1630 if (isReadWrite) 1631 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readwrite); 1632 1633 if (Attributes & ObjCDeclSpec::DQ_PR_retain) 1634 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_retain); 1635 1636 if (Attributes & ObjCDeclSpec::DQ_PR_copy) 1637 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_copy); 1638 1639 if (isAssign) 1640 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_assign); 1641 1642 if (Attributes & ObjCDeclSpec::DQ_PR_nonatomic) 1643 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_nonatomic); 1644 1645 if (MethodImplKind == tok::objc_required) 1646 PDecl->setPropertyImplementation(ObjCPropertyDecl::Required); 1647 else if (MethodImplKind == tok::objc_optional) 1648 PDecl->setPropertyImplementation(ObjCPropertyDecl::Optional); 1649 1650 return PDecl; 1651} 1652 1653/// ActOnPropertyImplDecl - This routine performs semantic checks and 1654/// builds the AST node for a property implementation declaration; declared 1655/// as @synthesize or @dynamic. 1656/// 1657Sema::DeclTy *Sema::ActOnPropertyImplDecl(SourceLocation AtLoc, 1658 SourceLocation PropertyLoc, 1659 bool Synthesize, 1660 DeclTy *ClassCatImpDecl, 1661 IdentifierInfo *PropertyId, 1662 IdentifierInfo *PropertyIvar) { 1663 Decl *ClassImpDecl = static_cast<Decl*>(ClassCatImpDecl); 1664 // Make sure we have a context for the property implementation declaration. 1665 if (!ClassImpDecl) { 1666 Diag(AtLoc, diag::error_missing_property_context); 1667 return 0; 1668 } 1669 ObjCPropertyDecl *property = 0; 1670 ObjCInterfaceDecl* IDecl = 0; 1671 // Find the class or category class where this property must have 1672 // a declaration. 1673 ObjCImplementationDecl *IC = 0; 1674 ObjCCategoryImplDecl* CatImplClass = 0; 1675 if ((IC = dyn_cast<ObjCImplementationDecl>(ClassImpDecl))) { 1676 IDecl = IC->getClassInterface(); 1677 // We always synthesize an interface for an implementation 1678 // without an interface decl. So, IDecl is always non-zero. 1679 assert(IDecl && 1680 "ActOnPropertyImplDecl - @implementation without @interface"); 1681 1682 // Look for this property declaration in the @implementation's @interface 1683 property = IDecl->FindPropertyDeclaration(PropertyId); 1684 if (!property) { 1685 Diag(PropertyLoc, diag::error_bad_property_decl) << IDecl->getDeclName(); 1686 return 0; 1687 } 1688 } 1689 else if ((CatImplClass = dyn_cast<ObjCCategoryImplDecl>(ClassImpDecl))) { 1690 if (Synthesize) { 1691 Diag(AtLoc, diag::error_synthesize_category_decl); 1692 return 0; 1693 } 1694 IDecl = CatImplClass->getClassInterface(); 1695 if (!IDecl) { 1696 Diag(AtLoc, diag::error_missing_property_interface); 1697 return 0; 1698 } 1699 ObjCCategoryDecl *Category = 1700 IDecl->FindCategoryDeclaration(CatImplClass->getIdentifier()); 1701 1702 // If category for this implementation not found, it is an error which 1703 // has already been reported eralier. 1704 if (!Category) 1705 return 0; 1706 // Look for this property declaration in @implementation's category 1707 property = Category->FindPropertyDeclaration(PropertyId); 1708 if (!property) { 1709 Diag(PropertyLoc, diag::error_bad_category_property_decl) 1710 << Category->getDeclName(); 1711 return 0; 1712 } 1713 } 1714 else { 1715 Diag(AtLoc, diag::error_bad_property_context); 1716 return 0; 1717 } 1718 ObjCIvarDecl *Ivar = 0; 1719 // Check that we have a valid, previously declared ivar for @synthesize 1720 if (Synthesize) { 1721 // @synthesize 1722 if (!PropertyIvar) 1723 PropertyIvar = PropertyId; 1724 // Check that this is a previously declared 'ivar' in 'IDecl' interface 1725 Ivar = IDecl->lookupInstanceVariable(PropertyIvar); 1726 if (!Ivar) { 1727 Diag(PropertyLoc, diag::error_missing_property_ivar_decl) << PropertyId; 1728 return 0; 1729 } 1730 QualType PropType = Context.getCanonicalType(property->getType()); 1731 QualType IvarType = Context.getCanonicalType(Ivar->getType()); 1732 1733 // Check that type of property and its ivar are type compatible. 1734 if (PropType != IvarType) { 1735 if (CheckAssignmentConstraints(PropType, IvarType) != Compatible) { 1736 Diag(PropertyLoc, diag::error_property_ivar_type) 1737 << property->getDeclName() << Ivar->getDeclName(); 1738 return 0; 1739 } 1740 else { 1741 // FIXME! Rules for properties are somewhat different that those 1742 // for assignments. Use a new routine to consolidate all cases; 1743 // specifically for property redeclarations as well as for ivars. 1744 QualType lhsType = 1745 Context.getCanonicalType(PropType).getUnqualifiedType(); 1746 QualType rhsType = 1747 Context.getCanonicalType(IvarType).getUnqualifiedType(); 1748 if (lhsType != rhsType && 1749 lhsType->isArithmeticType()) { 1750 Diag(PropertyLoc, diag::error_property_ivar_type) 1751 << property->getDeclName() << Ivar->getDeclName(); 1752 return 0; 1753 } 1754 // __weak is explicit. So it works on Canonical type. 1755 if (PropType.isObjCGCWeak() && !IvarType.isObjCGCWeak()) { 1756 Diag(PropertyLoc, diag::error_weak_property) 1757 << property->getDeclName() << Ivar->getDeclName(); 1758 return 0; 1759 } 1760 if ((Context.isObjCObjectPointerType(property->getType()) || 1761 PropType.isObjCGCStrong()) && IvarType.isObjCGCWeak()) { 1762 Diag(PropertyLoc, diag::error_strong_property) 1763 << property->getDeclName() << Ivar->getDeclName(); 1764 return 0; 1765 } 1766 } 1767 } 1768 } else if (PropertyIvar) { 1769 // @dynamic 1770 Diag(PropertyLoc, diag::error_dynamic_property_ivar_decl); 1771 return 0; 1772 } 1773 assert (property && "ActOnPropertyImplDecl - property declaration missing"); 1774 ObjCPropertyImplDecl *PIDecl = 1775 ObjCPropertyImplDecl::Create(Context, CurContext, AtLoc, PropertyLoc, 1776 property, 1777 (Synthesize ? 1778 ObjCPropertyImplDecl::Synthesize 1779 : ObjCPropertyImplDecl::Dynamic), 1780 Ivar); 1781 CurContext->addDecl(PIDecl); 1782 if (IC) { 1783 if (Synthesize) 1784 if (ObjCPropertyImplDecl *PPIDecl = 1785 IC->FindPropertyImplIvarDecl(PropertyIvar)) { 1786 Diag(PropertyLoc, diag::error_duplicate_ivar_use) 1787 << PropertyId << PPIDecl->getPropertyDecl()->getIdentifier() 1788 << PropertyIvar; 1789 Diag(PPIDecl->getLocation(), diag::note_previous_use); 1790 } 1791 1792 if (ObjCPropertyImplDecl *PPIDecl = IC->FindPropertyImplDecl(PropertyId)) { 1793 Diag(PropertyLoc, diag::error_property_implemented) << PropertyId; 1794 Diag(PPIDecl->getLocation(), diag::note_previous_declaration); 1795 return 0; 1796 } 1797 IC->addPropertyImplementation(PIDecl); 1798 } 1799 else { 1800 if (Synthesize) 1801 if (ObjCPropertyImplDecl *PPIDecl = 1802 CatImplClass->FindPropertyImplIvarDecl(PropertyIvar)) { 1803 Diag(PropertyLoc, diag::error_duplicate_ivar_use) 1804 << PropertyId << PPIDecl->getPropertyDecl()->getIdentifier() 1805 << PropertyIvar; 1806 Diag(PPIDecl->getLocation(), diag::note_previous_use); 1807 } 1808 1809 if (ObjCPropertyImplDecl *PPIDecl = 1810 CatImplClass->FindPropertyImplDecl(PropertyId)) { 1811 Diag(PropertyLoc, diag::error_property_implemented) << PropertyId; 1812 Diag(PPIDecl->getLocation(), diag::note_previous_declaration); 1813 return 0; 1814 } 1815 CatImplClass->addPropertyImplementation(PIDecl); 1816 } 1817 1818 return PIDecl; 1819} 1820 1821bool Sema::CheckObjCDeclScope(Decl *D) { 1822 if (isa<TranslationUnitDecl>(CurContext->getLookupContext())) 1823 return false; 1824 1825 Diag(D->getLocation(), diag::err_objc_decls_may_only_appear_in_global_scope); 1826 D->setInvalidDecl(); 1827 1828 return true; 1829} 1830 1831/// Collect the instance variables declared in an Objective-C object. Used in 1832/// the creation of structures from objects using the @defs directive. 1833/// FIXME: This should be consolidated with CollectObjCIvars as it is also 1834/// part of the AST generation logic of @defs. 1835static void CollectIvars(ObjCInterfaceDecl *Class, RecordDecl *Record, 1836 ASTContext& Ctx, 1837 llvm::SmallVectorImpl<Sema::DeclTy*> &ivars) { 1838 if (Class->getSuperClass()) 1839 CollectIvars(Class->getSuperClass(), Record, Ctx, ivars); 1840 1841 // For each ivar, create a fresh ObjCAtDefsFieldDecl. 1842 for (ObjCInterfaceDecl::ivar_iterator 1843 I=Class->ivar_begin(), E=Class->ivar_end(); I!=E; ++I) { 1844 1845 ObjCIvarDecl* ID = *I; 1846 ivars.push_back(ObjCAtDefsFieldDecl::Create(Ctx, Record, 1847 ID->getLocation(), 1848 ID->getIdentifier(), 1849 ID->getType(), 1850 ID->getBitWidth())); 1851 } 1852} 1853 1854/// Called whenever @defs(ClassName) is encountered in the source. Inserts the 1855/// instance variables of ClassName into Decls. 1856void Sema::ActOnDefs(Scope *S, DeclTy *TagD, SourceLocation DeclStart, 1857 IdentifierInfo *ClassName, 1858 llvm::SmallVectorImpl<DeclTy*> &Decls) { 1859 // Check that ClassName is a valid class 1860 ObjCInterfaceDecl *Class = getObjCInterfaceDecl(ClassName); 1861 if (!Class) { 1862 Diag(DeclStart, diag::err_undef_interface) << ClassName; 1863 return; 1864 } 1865 // Collect the instance variables 1866 CollectIvars(Class, dyn_cast<RecordDecl>((Decl*)TagD), Context, Decls); 1867 1868 // Introduce all of these fields into the appropriate scope. 1869 for (llvm::SmallVectorImpl<DeclTy*>::iterator D = Decls.begin(); 1870 D != Decls.end(); ++D) { 1871 FieldDecl *FD = cast<FieldDecl>((Decl*)*D); 1872 if (getLangOptions().CPlusPlus) 1873 PushOnScopeChains(cast<FieldDecl>(FD), S); 1874 else if (RecordDecl *Record = dyn_cast<RecordDecl>((Decl*)TagD)) 1875 Record->addDecl(FD); 1876 } 1877} 1878 1879