SemaDeclObjC.cpp revision de7394157c3f83af55053128178aa71bdb08101c
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/Basic/Diagnostic.h" 18#include "clang/Parse/DeclSpec.h" 19 20using namespace clang; 21 22/// ObjCActOnStartOfMethodDef - This routine sets up parameters; invisible 23/// and user declared, in the method definition's AST. 24void Sema::ObjCActOnStartOfMethodDef(Scope *FnBodyScope, DeclTy *D) { 25 assert(getCurMethodDecl() == 0 && "Method parsing confused"); 26 ObjCMethodDecl *MDecl = dyn_cast_or_null<ObjCMethodDecl>((Decl *)D); 27 28 // If we don't have a valid method decl, simply return. 29 if (!MDecl) 30 return; 31 32 // Allow the rest of sema to find private method decl implementations. 33 if (MDecl->isInstance()) 34 AddInstanceMethodToGlobalPool(MDecl); 35 else 36 AddFactoryMethodToGlobalPool(MDecl); 37 38 // Allow all of Sema to see that we are entering a method definition. 39 PushDeclContext(MDecl); 40 41 // Create Decl objects for each parameter, entrring them in the scope for 42 // binding to their use. 43 44 // Insert the invisible arguments, self and _cmd! 45 MDecl->createImplicitParams(Context); 46 47 PushOnScopeChains(MDecl->getSelfDecl(), FnBodyScope); 48 PushOnScopeChains(MDecl->getCmdDecl(), FnBodyScope); 49 50 // Introduce all of the other parameters into this scope. 51 for (unsigned i = 0, e = MDecl->getNumParams(); i != e; ++i) { 52 ParmVarDecl *PDecl = MDecl->getParamDecl(i); 53 IdentifierInfo *II = PDecl->getIdentifier(); 54 if (II) 55 PushOnScopeChains(PDecl, FnBodyScope); 56 } 57} 58 59Sema::DeclTy *Sema:: 60ActOnStartClassInterface(SourceLocation AtInterfaceLoc, 61 IdentifierInfo *ClassName, SourceLocation ClassLoc, 62 IdentifierInfo *SuperName, SourceLocation SuperLoc, 63 DeclTy * const *ProtoRefs, unsigned NumProtoRefs, 64 SourceLocation EndProtoLoc, AttributeList *AttrList) { 65 assert(ClassName && "Missing class identifier"); 66 67 // Check for another declaration kind with the same name. 68 Decl *PrevDecl = LookupDecl(ClassName, Decl::IDNS_Ordinary, TUScope); 69 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) { 70 Diag(ClassLoc, diag::err_redefinition_different_kind) << ClassName; 71 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 72 } 73 74 ObjCInterfaceDecl* IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl); 75 if (IDecl) { 76 // Class already seen. Is it a forward declaration? 77 if (!IDecl->isForwardDecl()) { 78 Diag(AtInterfaceLoc, diag::err_duplicate_class_def)<<IDecl->getDeclName(); 79 Diag(IDecl->getLocation(), diag::note_previous_definition); 80 81 // Return the previous class interface. 82 // FIXME: don't leak the objects passed in! 83 return IDecl; 84 } else { 85 IDecl->setLocation(AtInterfaceLoc); 86 IDecl->setForwardDecl(false); 87 } 88 } else { 89 IDecl = ObjCInterfaceDecl::Create(Context, AtInterfaceLoc, 90 ClassName, ClassLoc); 91 if (AttrList) 92 ProcessDeclAttributeList(IDecl, AttrList); 93 94 ObjCInterfaceDecls[ClassName] = IDecl; 95 // Remember that this needs to be removed when the scope is popped. 96 TUScope->AddDecl(IDecl); 97 } 98 99 if (SuperName) { 100 ObjCInterfaceDecl* SuperClassEntry = 0; 101 // Check if a different kind of symbol declared in this scope. 102 PrevDecl = LookupDecl(SuperName, Decl::IDNS_Ordinary, TUScope); 103 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) { 104 Diag(SuperLoc, diag::err_redefinition_different_kind) << SuperName; 105 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 106 } 107 else { 108 // Check that super class is previously defined 109 SuperClassEntry = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl); 110 111 if (!SuperClassEntry) 112 Diag(SuperLoc, diag::err_undef_superclass) 113 << SuperName << ClassName << SourceRange(AtInterfaceLoc, ClassLoc); 114 else if (SuperClassEntry->isForwardDecl()) 115 Diag(SuperLoc, diag::err_undef_superclass) 116 << SuperClassEntry->getDeclName() << ClassName 117 << SourceRange(AtInterfaceLoc, ClassLoc); 118 } 119 IDecl->setSuperClass(SuperClassEntry); 120 IDecl->setSuperClassLoc(SuperLoc); 121 IDecl->setLocEnd(SuperLoc); 122 } else { // we have a root class. 123 IDecl->setLocEnd(ClassLoc); 124 } 125 126 /// Check then save referenced protocols. 127 if (NumProtoRefs) { 128 IDecl->addReferencedProtocols((ObjCProtocolDecl**)ProtoRefs, NumProtoRefs); 129 IDecl->setLocEnd(EndProtoLoc); 130 } 131 132 CheckObjCDeclScope(IDecl); 133 return IDecl; 134} 135 136/// ActOnCompatiblityAlias - this action is called after complete parsing of 137/// @compatibility_alias declaration. It sets up the alias relationships. 138Sema::DeclTy *Sema::ActOnCompatiblityAlias(SourceLocation AtLoc, 139 IdentifierInfo *AliasName, 140 SourceLocation AliasLocation, 141 IdentifierInfo *ClassName, 142 SourceLocation ClassLocation) { 143 // Look for previous declaration of alias name 144 Decl *ADecl = LookupDecl(AliasName, Decl::IDNS_Ordinary, TUScope); 145 if (ADecl) { 146 if (isa<ObjCCompatibleAliasDecl>(ADecl)) 147 Diag(AliasLocation, diag::warn_previous_alias_decl); 148 else 149 Diag(AliasLocation, diag::err_conflicting_aliasing_type) << AliasName; 150 Diag(ADecl->getLocation(), diag::note_previous_declaration); 151 return 0; 152 } 153 // Check for class declaration 154 Decl *CDeclU = LookupDecl(ClassName, Decl::IDNS_Ordinary, TUScope); 155 ObjCInterfaceDecl *CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(CDeclU); 156 if (CDecl == 0) { 157 Diag(ClassLocation, diag::warn_undef_interface) << ClassName; 158 if (CDeclU) 159 Diag(CDeclU->getLocation(), diag::note_previous_declaration); 160 return 0; 161 } 162 163 // Everything checked out, instantiate a new alias declaration AST. 164 ObjCCompatibleAliasDecl *AliasDecl = 165 ObjCCompatibleAliasDecl::Create(Context, AtLoc, AliasName, CDecl); 166 167 ObjCAliasDecls[AliasName] = AliasDecl; 168 169 if (!CheckObjCDeclScope(AliasDecl)) 170 TUScope->AddDecl(AliasDecl); 171 172 return AliasDecl; 173} 174 175Sema::DeclTy * 176Sema::ActOnStartProtocolInterface(SourceLocation AtProtoInterfaceLoc, 177 IdentifierInfo *ProtocolName, 178 SourceLocation ProtocolLoc, 179 DeclTy * const *ProtoRefs, 180 unsigned NumProtoRefs, 181 SourceLocation EndProtoLoc, 182 AttributeList *AttrList) { 183 // FIXME: Deal with AttrList. 184 assert(ProtocolName && "Missing protocol identifier"); 185 ObjCProtocolDecl *PDecl = ObjCProtocols[ProtocolName]; 186 if (PDecl) { 187 // Protocol already seen. Better be a forward protocol declaration 188 if (!PDecl->isForwardDecl()) { 189 Diag(ProtocolLoc, diag::err_duplicate_protocol_def) << ProtocolName; 190 Diag(PDecl->getLocation(), diag::note_previous_definition); 191 // Just return the protocol we already had. 192 // FIXME: don't leak the objects passed in! 193 return PDecl; 194 } 195 // Make sure the cached decl gets a valid start location. 196 PDecl->setLocation(AtProtoInterfaceLoc); 197 PDecl->setForwardDecl(false); 198 } else { 199 PDecl = ObjCProtocolDecl::Create(Context, AtProtoInterfaceLoc,ProtocolName); 200 PDecl->setForwardDecl(false); 201 ObjCProtocols[ProtocolName] = PDecl; 202 } 203 204 if (NumProtoRefs) { 205 /// Check then save referenced protocols. 206 PDecl->addReferencedProtocols((ObjCProtocolDecl**)ProtoRefs, NumProtoRefs); 207 PDecl->setLocEnd(EndProtoLoc); 208 } 209 210 CheckObjCDeclScope(PDecl); 211 return PDecl; 212} 213 214/// FindProtocolDeclaration - This routine looks up protocols and 215/// issues an error if they are not declared. It returns list of 216/// protocol declarations in its 'Protocols' argument. 217void 218Sema::FindProtocolDeclaration(bool WarnOnDeclarations, 219 const IdentifierLocPair *ProtocolId, 220 unsigned NumProtocols, 221 llvm::SmallVectorImpl<DeclTy*> &Protocols) { 222 for (unsigned i = 0; i != NumProtocols; ++i) { 223 ObjCProtocolDecl *PDecl = ObjCProtocols[ProtocolId[i].first]; 224 if (!PDecl) { 225 Diag(ProtocolId[i].second, diag::err_undeclared_protocol) 226 << ProtocolId[i].first; 227 continue; 228 } 229 230 // If this is a forward declaration and we are supposed to warn in this 231 // case, do it. 232 if (WarnOnDeclarations && PDecl->isForwardDecl()) 233 Diag(ProtocolId[i].second, diag::warn_undef_protocolref) 234 << ProtocolId[i].first; 235 Protocols.push_back(PDecl); 236 } 237} 238 239/// DiagnosePropertyMismatch - Compares two properties for their 240/// attributes and types and warns on a variety of inconsistencies. 241/// 242void 243Sema::DiagnosePropertyMismatch(ObjCPropertyDecl *Property, 244 ObjCPropertyDecl *SuperProperty, 245 const IdentifierInfo *inheritedName) { 246 ObjCPropertyDecl::PropertyAttributeKind CAttr = 247 Property->getPropertyAttributes(); 248 ObjCPropertyDecl::PropertyAttributeKind SAttr = 249 SuperProperty->getPropertyAttributes(); 250 if ((CAttr & ObjCPropertyDecl::OBJC_PR_readonly) 251 && (SAttr & ObjCPropertyDecl::OBJC_PR_readwrite)) 252 Diag(Property->getLocation(), diag::warn_readonly_property) 253 << Property->getDeclName() << inheritedName; 254 if ((CAttr & ObjCPropertyDecl::OBJC_PR_copy) 255 != (SAttr & ObjCPropertyDecl::OBJC_PR_copy)) 256 Diag(Property->getLocation(), diag::warn_property_attribute) 257 << Property->getDeclName() << "copy" << inheritedName; 258 else if ((CAttr & ObjCPropertyDecl::OBJC_PR_retain) 259 != (SAttr & ObjCPropertyDecl::OBJC_PR_retain)) 260 Diag(Property->getLocation(), diag::warn_property_attribute) 261 << Property->getDeclName() << "retain" << inheritedName; 262 263 if ((CAttr & ObjCPropertyDecl::OBJC_PR_nonatomic) 264 != (SAttr & ObjCPropertyDecl::OBJC_PR_nonatomic)) 265 Diag(Property->getLocation(), diag::warn_property_attribute) 266 << Property->getDeclName() << "atomic" << inheritedName; 267 if (Property->getSetterName() != SuperProperty->getSetterName()) 268 Diag(Property->getLocation(), diag::warn_property_attribute) 269 << Property->getDeclName() << "setter" << inheritedName; 270 if (Property->getGetterName() != SuperProperty->getGetterName()) 271 Diag(Property->getLocation(), diag::warn_property_attribute) 272 << Property->getDeclName() << "getter" << inheritedName; 273 274 if (Context.getCanonicalType(Property->getType()) != 275 Context.getCanonicalType(SuperProperty->getType())) 276 Diag(Property->getLocation(), diag::warn_property_type) 277 << Property->getType() << inheritedName; 278 279} 280 281/// ComparePropertiesInBaseAndSuper - This routine compares property 282/// declarations in base and its super class, if any, and issues 283/// diagnostics in a variety of inconsistant situations. 284/// 285void 286Sema::ComparePropertiesInBaseAndSuper(ObjCInterfaceDecl *IDecl) { 287 ObjCInterfaceDecl *SDecl = IDecl->getSuperClass(); 288 if (!SDecl) 289 return; 290 // FIXME: O(N^2) 291 for (ObjCInterfaceDecl::classprop_iterator S = SDecl->classprop_begin(), 292 E = SDecl->classprop_end(); S != E; ++S) { 293 ObjCPropertyDecl *SuperPDecl = (*S); 294 // Does property in super class has declaration in current class? 295 for (ObjCInterfaceDecl::classprop_iterator I = IDecl->classprop_begin(), 296 E = IDecl->classprop_end(); I != E; ++I) { 297 ObjCPropertyDecl *PDecl = (*I); 298 if (SuperPDecl->getIdentifier() == PDecl->getIdentifier()) 299 DiagnosePropertyMismatch(PDecl, SuperPDecl, 300 SDecl->getIdentifier()); 301 } 302 } 303} 304 305/// MergeOneProtocolPropertiesIntoClass - This routine goes thru the list 306/// of properties declared in a protocol and adds them to the list 307/// of properties for current class if it is not there already. 308void 309Sema::MergeOneProtocolPropertiesIntoClass(ObjCInterfaceDecl *IDecl, 310 ObjCProtocolDecl *PDecl) { 311 llvm::SmallVector<ObjCPropertyDecl*, 16> mergeProperties; 312 for (ObjCProtocolDecl::classprop_iterator P = PDecl->classprop_begin(), 313 E = PDecl->classprop_end(); P != E; ++P) { 314 ObjCPropertyDecl *Pr = (*P); 315 ObjCInterfaceDecl::classprop_iterator CP, CE; 316 // Is this property already in class's list of properties? 317 for (CP = IDecl->classprop_begin(), CE = IDecl->classprop_end(); 318 CP != CE; ++CP) 319 if ((*CP)->getIdentifier() == Pr->getIdentifier()) 320 break; 321 if (CP == CE) 322 // Add this property to list of properties for thie class. 323 mergeProperties.push_back(Pr); 324 else 325 // Property protocol already exist in class. Diagnose any mismatch. 326 DiagnosePropertyMismatch((*CP), Pr, PDecl->getIdentifier()); 327 } 328 IDecl->mergeProperties(&mergeProperties[0], mergeProperties.size()); 329} 330 331/// MergeProtocolPropertiesIntoClass - This routine merges properties 332/// declared in 'MergeItsProtocols' objects (which can be a class or an 333/// inherited protocol into the list of properties for class 'IDecl' 334/// 335 336void 337Sema::MergeProtocolPropertiesIntoClass(ObjCInterfaceDecl *IDecl, 338 DeclTy *MergeItsProtocols) { 339 Decl *ClassDecl = static_cast<Decl *>(MergeItsProtocols); 340 if (ObjCInterfaceDecl *MDecl = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) { 341 for (ObjCInterfaceDecl::protocol_iterator P = MDecl->protocol_begin(), 342 E = MDecl->protocol_end(); P != E; ++P) 343 // Merge properties of class (*P) into IDECL's 344 MergeOneProtocolPropertiesIntoClass(IDecl, *P); 345 346 // Go thru the list of protocols for this class and recursively merge 347 // their properties into this class as well. 348 for (ObjCInterfaceDecl::protocol_iterator P = IDecl->protocol_begin(), 349 E = IDecl->protocol_end(); P != E; ++P) 350 MergeProtocolPropertiesIntoClass(IDecl, *P); 351 } else { 352 ObjCProtocolDecl *MD = cast<ObjCProtocolDecl>(ClassDecl); 353 for (ObjCProtocolDecl::protocol_iterator P = MD->protocol_begin(), 354 E = MD->protocol_end(); P != E; ++P) 355 MergeOneProtocolPropertiesIntoClass(IDecl, (*P)); 356 } 357} 358 359/// ActOnForwardProtocolDeclaration - 360Action::DeclTy * 361Sema::ActOnForwardProtocolDeclaration(SourceLocation AtProtocolLoc, 362 const IdentifierLocPair *IdentList, 363 unsigned NumElts) { 364 llvm::SmallVector<ObjCProtocolDecl*, 32> Protocols; 365 366 for (unsigned i = 0; i != NumElts; ++i) { 367 IdentifierInfo *Ident = IdentList[i].first; 368 ObjCProtocolDecl *&PDecl = ObjCProtocols[Ident]; 369 if (PDecl == 0) // Not already seen? 370 PDecl = ObjCProtocolDecl::Create(Context, IdentList[i].second, Ident); 371 372 Protocols.push_back(PDecl); 373 } 374 375 ObjCForwardProtocolDecl *PDecl = 376 ObjCForwardProtocolDecl::Create(Context, AtProtocolLoc, 377 &Protocols[0], Protocols.size()); 378 379 CheckObjCDeclScope(PDecl); 380 return PDecl; 381} 382 383Sema::DeclTy *Sema:: 384ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc, 385 IdentifierInfo *ClassName, SourceLocation ClassLoc, 386 IdentifierInfo *CategoryName, 387 SourceLocation CategoryLoc, 388 DeclTy * const *ProtoRefs, 389 unsigned NumProtoRefs, 390 SourceLocation EndProtoLoc) { 391 ObjCInterfaceDecl *IDecl = getObjCInterfaceDecl(ClassName); 392 393 ObjCCategoryDecl *CDecl = 394 ObjCCategoryDecl::Create(Context, AtInterfaceLoc, CategoryName); 395 CDecl->setClassInterface(IDecl); 396 397 /// Check that class of this category is already completely declared. 398 if (!IDecl || IDecl->isForwardDecl()) 399 Diag(ClassLoc, diag::err_undef_interface) << ClassName; 400 else { 401 /// Check for duplicate interface declaration for this category 402 ObjCCategoryDecl *CDeclChain; 403 for (CDeclChain = IDecl->getCategoryList(); CDeclChain; 404 CDeclChain = CDeclChain->getNextClassCategory()) { 405 if (CategoryName && CDeclChain->getIdentifier() == CategoryName) { 406 Diag(CategoryLoc, diag::warn_dup_category_def) 407 << ClassName << CategoryName; 408 Diag(CDeclChain->getLocation(), diag::note_previous_definition); 409 break; 410 } 411 } 412 if (!CDeclChain) 413 CDecl->insertNextClassCategory(); 414 } 415 416 if (NumProtoRefs) { 417 CDecl->addReferencedProtocols((ObjCProtocolDecl**)ProtoRefs, NumProtoRefs); 418 CDecl->setLocEnd(EndProtoLoc); 419 } 420 421 CheckObjCDeclScope(CDecl); 422 return CDecl; 423} 424 425/// ActOnStartCategoryImplementation - Perform semantic checks on the 426/// category implementation declaration and build an ObjCCategoryImplDecl 427/// object. 428Sema::DeclTy *Sema::ActOnStartCategoryImplementation( 429 SourceLocation AtCatImplLoc, 430 IdentifierInfo *ClassName, SourceLocation ClassLoc, 431 IdentifierInfo *CatName, SourceLocation CatLoc) { 432 ObjCInterfaceDecl *IDecl = getObjCInterfaceDecl(ClassName); 433 ObjCCategoryImplDecl *CDecl = 434 ObjCCategoryImplDecl::Create(Context, AtCatImplLoc, CatName, IDecl); 435 /// Check that class of this category is already completely declared. 436 if (!IDecl || IDecl->isForwardDecl()) 437 Diag(ClassLoc, diag::err_undef_interface) << ClassName; 438 439 /// TODO: Check that CatName, category name, is not used in another 440 // implementation. 441 ObjCCategoryImpls.push_back(CDecl); 442 443 CheckObjCDeclScope(CDecl); 444 return CDecl; 445} 446 447Sema::DeclTy *Sema::ActOnStartClassImplementation( 448 SourceLocation AtClassImplLoc, 449 IdentifierInfo *ClassName, SourceLocation ClassLoc, 450 IdentifierInfo *SuperClassname, 451 SourceLocation SuperClassLoc) { 452 ObjCInterfaceDecl* IDecl = 0; 453 // Check for another declaration kind with the same name. 454 Decl *PrevDecl = LookupDecl(ClassName, Decl::IDNS_Ordinary, TUScope); 455 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) { 456 Diag(ClassLoc, diag::err_redefinition_different_kind) << ClassName; 457 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 458 } 459 else { 460 // Is there an interface declaration of this class; if not, warn! 461 IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl); 462 if (!IDecl) 463 Diag(ClassLoc, diag::warn_undef_interface) << ClassName; 464 } 465 466 // Check that super class name is valid class name 467 ObjCInterfaceDecl* SDecl = 0; 468 if (SuperClassname) { 469 // Check if a different kind of symbol declared in this scope. 470 PrevDecl = LookupDecl(SuperClassname, Decl::IDNS_Ordinary, TUScope); 471 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) { 472 Diag(SuperClassLoc, diag::err_redefinition_different_kind) 473 << SuperClassname; 474 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 475 } else { 476 SDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl); 477 if (!SDecl) 478 Diag(SuperClassLoc, diag::err_undef_superclass) 479 << SuperClassname << ClassName; 480 else if (IDecl && IDecl->getSuperClass() != SDecl) { 481 // This implementation and its interface do not have the same 482 // super class. 483 Diag(SuperClassLoc, diag::err_conflicting_super_class) 484 << SDecl->getDeclName(); 485 Diag(SDecl->getLocation(), diag::note_previous_definition); 486 } 487 } 488 } 489 490 if (!IDecl) { 491 // Legacy case of @implementation with no corresponding @interface. 492 // Build, chain & install the interface decl into the identifier. 493 494 // FIXME: Do we support attributes on the @implementation? If so 495 // we should copy them over. 496 IDecl = ObjCInterfaceDecl::Create(Context, AtClassImplLoc, ClassName, 497 ClassLoc, false, true); 498 ObjCInterfaceDecls[ClassName] = IDecl; 499 IDecl->setSuperClass(SDecl); 500 IDecl->setLocEnd(ClassLoc); 501 502 // Remember that this needs to be removed when the scope is popped. 503 TUScope->AddDecl(IDecl); 504 } 505 506 ObjCImplementationDecl* IMPDecl = 507 ObjCImplementationDecl::Create(Context, AtClassImplLoc, ClassName, 508 IDecl, SDecl); 509 510 if (CheckObjCDeclScope(IMPDecl)) 511 return IMPDecl; 512 513 // Check that there is no duplicate implementation of this class. 514 if (ObjCImplementations[ClassName]) 515 // FIXME: Don't leak everything! 516 Diag(ClassLoc, diag::err_dup_implementation_class) << ClassName; 517 else // add it to the list. 518 ObjCImplementations[ClassName] = IMPDecl; 519 return IMPDecl; 520} 521 522void Sema::CheckImplementationIvars(ObjCImplementationDecl *ImpDecl, 523 ObjCIvarDecl **ivars, unsigned numIvars, 524 SourceLocation RBrace) { 525 assert(ImpDecl && "missing implementation decl"); 526 ObjCInterfaceDecl* IDecl = getObjCInterfaceDecl(ImpDecl->getIdentifier()); 527 if (!IDecl) 528 return; 529 /// Check case of non-existing @interface decl. 530 /// (legacy objective-c @implementation decl without an @interface decl). 531 /// Add implementations's ivar to the synthesize class's ivar list. 532 if (IDecl->ImplicitInterfaceDecl()) { 533 IDecl->addInstanceVariablesToClass(ivars, numIvars, RBrace); 534 return; 535 } 536 // If implementation has empty ivar list, just return. 537 if (numIvars == 0) 538 return; 539 540 assert(ivars && "missing @implementation ivars"); 541 542 // Check interface's Ivar list against those in the implementation. 543 // names and types must match. 544 // 545 unsigned j = 0; 546 ObjCInterfaceDecl::ivar_iterator 547 IVI = IDecl->ivar_begin(), IVE = IDecl->ivar_end(); 548 for (; numIvars > 0 && IVI != IVE; ++IVI) { 549 ObjCIvarDecl* ImplIvar = ivars[j++]; 550 ObjCIvarDecl* ClsIvar = *IVI; 551 assert (ImplIvar && "missing implementation ivar"); 552 assert (ClsIvar && "missing class ivar"); 553 if (Context.getCanonicalType(ImplIvar->getType()) != 554 Context.getCanonicalType(ClsIvar->getType())) { 555 Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_type) 556 << ImplIvar->getIdentifier() 557 << ImplIvar->getType() << ClsIvar->getType(); 558 Diag(ClsIvar->getLocation(), diag::note_previous_definition); 559 } 560 // TODO: Two mismatched (unequal width) Ivar bitfields should be diagnosed 561 // as error. 562 else if (ImplIvar->getIdentifier() != ClsIvar->getIdentifier()) { 563 Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_name) 564 << ImplIvar->getIdentifier() << ClsIvar->getIdentifier(); 565 Diag(ClsIvar->getLocation(), diag::note_previous_definition); 566 return; 567 } 568 --numIvars; 569 } 570 571 if (numIvars > 0) 572 Diag(ivars[j]->getLocation(), diag::err_inconsistant_ivar_count); 573 else if (IVI != IVE) 574 Diag((*IVI)->getLocation(), diag::err_inconsistant_ivar_count); 575} 576 577void Sema::WarnUndefinedMethod(SourceLocation ImpLoc, ObjCMethodDecl *method, 578 bool &IncompleteImpl) { 579 if (!IncompleteImpl) { 580 Diag(ImpLoc, diag::warn_incomplete_impl); 581 IncompleteImpl = true; 582 } 583 Diag(ImpLoc, diag::warn_undef_method_impl) << method->getDeclName(); 584} 585 586/// FIXME: Type hierarchies in Objective-C can be deep. We could most 587/// likely improve the efficiency of selector lookups and type 588/// checking by associating with each protocol / interface / category 589/// the flattened instance tables. If we used an immutable set to keep 590/// the table then it wouldn't add significant memory cost and it 591/// would be handy for lookups. 592 593/// CheckProtocolMethodDefs - This routine checks unimplemented methods 594/// Declared in protocol, and those referenced by it. 595void Sema::CheckProtocolMethodDefs(SourceLocation ImpLoc, 596 ObjCProtocolDecl *PDecl, 597 bool& IncompleteImpl, 598 const llvm::DenseSet<Selector> &InsMap, 599 const llvm::DenseSet<Selector> &ClsMap, 600 ObjCInterfaceDecl *IDecl) { 601 ObjCInterfaceDecl *Super = IDecl->getSuperClass(); 602 603 // If a method lookup fails locally we still need to look and see if 604 // the method was implemented by a base class or an inherited 605 // protocol. This lookup is slow, but occurs rarely in correct code 606 // and otherwise would terminate in a warning. 607 608 // check unimplemented instance methods. 609 for (ObjCProtocolDecl::instmeth_iterator I = PDecl->instmeth_begin(), 610 E = PDecl->instmeth_end(); I != E; ++I) { 611 ObjCMethodDecl *method = *I; 612 if (method->getImplementationControl() != ObjCMethodDecl::Optional && 613 !method->isSynthesized() && !InsMap.count(method->getSelector()) && 614 (!Super || !Super->lookupInstanceMethod(method->getSelector()))) 615 WarnUndefinedMethod(ImpLoc, method, IncompleteImpl); 616 } 617 // check unimplemented class methods 618 for (ObjCProtocolDecl::classmeth_iterator I = PDecl->classmeth_begin(), 619 E = PDecl->classmeth_end(); I != E; ++I) { 620 ObjCMethodDecl *method = *I; 621 if (method->getImplementationControl() != ObjCMethodDecl::Optional && 622 !ClsMap.count(method->getSelector()) && 623 (!Super || !Super->lookupClassMethod(method->getSelector()))) 624 WarnUndefinedMethod(ImpLoc, method, IncompleteImpl); 625 } 626 // Check on this protocols's referenced protocols, recursively. 627 for (ObjCProtocolDecl::protocol_iterator PI = PDecl->protocol_begin(), 628 E = PDecl->protocol_end(); PI != E; ++PI) 629 CheckProtocolMethodDefs(ImpLoc, *PI, IncompleteImpl, InsMap, ClsMap, IDecl); 630} 631 632void Sema::ImplMethodsVsClassMethods(ObjCImplementationDecl* IMPDecl, 633 ObjCInterfaceDecl* IDecl) { 634 llvm::DenseSet<Selector> InsMap; 635 // Check and see if instance methods in class interface have been 636 // implemented in the implementation class. 637 for (ObjCImplementationDecl::instmeth_iterator I = IMPDecl->instmeth_begin(), 638 E = IMPDecl->instmeth_end(); I != E; ++I) 639 InsMap.insert((*I)->getSelector()); 640 641 bool IncompleteImpl = false; 642 for (ObjCInterfaceDecl::instmeth_iterator I = IDecl->instmeth_begin(), 643 E = IDecl->instmeth_end(); I != E; ++I) 644 if (!(*I)->isSynthesized() && !InsMap.count((*I)->getSelector())) 645 WarnUndefinedMethod(IMPDecl->getLocation(), *I, IncompleteImpl); 646 else if (!(*I)->isSynthesized()){ 647 bool err = false; 648 ObjCMethodDecl *ImpMethodDecl = 649 IMPDecl->getInstanceMethod((*I)->getSelector()); 650 ObjCMethodDecl *IntfMethodDecl = 651 IDecl->getInstanceMethod((*I)->getSelector()); 652 QualType ImpMethodQType = 653 Context.getCanonicalType(ImpMethodDecl->getResultType()); 654 QualType IntfMethodQType = 655 Context.getCanonicalType(IntfMethodDecl->getResultType()); 656 if (!Context.typesAreCompatible(IntfMethodQType, ImpMethodQType)) 657 err = true; 658 else for (ObjCMethodDecl::param_iterator IM=ImpMethodDecl->param_begin(), 659 IF=IntfMethodDecl->param_begin(), 660 EM=ImpMethodDecl->param_end(); IM!=EM; ++IM, IF++) { 661 ImpMethodQType = Context.getCanonicalType((*IM)->getType()); 662 IntfMethodQType = Context.getCanonicalType((*IF)->getType()); 663 if (!Context.typesAreCompatible(IntfMethodQType, ImpMethodQType)) { 664 err = true; 665 break; 666 } 667 } 668 if (err) { 669 Diag(ImpMethodDecl->getLocation(), diag::err_conflicting_types) 670 << ImpMethodDecl->getDeclName(); 671 Diag(IntfMethodDecl->getLocation(), diag::note_previous_definition); 672 } 673 } 674 675 llvm::DenseSet<Selector> ClsMap; 676 // Check and see if class methods in class interface have been 677 // implemented in the implementation class. 678 for (ObjCImplementationDecl::classmeth_iterator I =IMPDecl->classmeth_begin(), 679 E = IMPDecl->classmeth_end(); I != E; ++I) 680 ClsMap.insert((*I)->getSelector()); 681 682 for (ObjCInterfaceDecl::classmeth_iterator I = IDecl->classmeth_begin(), 683 E = IDecl->classmeth_end(); I != E; ++I) 684 if (!ClsMap.count((*I)->getSelector())) 685 WarnUndefinedMethod(IMPDecl->getLocation(), *I, IncompleteImpl); 686 687 // Check the protocol list for unimplemented methods in the @implementation 688 // class. 689 const ObjCList<ObjCProtocolDecl> &Protocols = 690 IDecl->getReferencedProtocols(); 691 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 692 E = Protocols.end(); I != E; ++I) 693 CheckProtocolMethodDefs(IMPDecl->getLocation(), *I, 694 IncompleteImpl, InsMap, ClsMap, IDecl); 695} 696 697/// ImplCategoryMethodsVsIntfMethods - Checks that methods declared in the 698/// category interface are implemented in the category @implementation. 699void Sema::ImplCategoryMethodsVsIntfMethods(ObjCCategoryImplDecl *CatImplDecl, 700 ObjCCategoryDecl *CatClassDecl) { 701 llvm::DenseSet<Selector> InsMap; 702 // Check and see if instance methods in category interface have been 703 // implemented in its implementation class. 704 for (ObjCCategoryImplDecl::instmeth_iterator I =CatImplDecl->instmeth_begin(), 705 E = CatImplDecl->instmeth_end(); I != E; ++I) 706 InsMap.insert((*I)->getSelector()); 707 708 bool IncompleteImpl = false; 709 for (ObjCCategoryDecl::instmeth_iterator I = CatClassDecl->instmeth_begin(), 710 E = CatClassDecl->instmeth_end(); I != E; ++I) 711 if (!InsMap.count((*I)->getSelector())) 712 WarnUndefinedMethod(CatImplDecl->getLocation(), *I, IncompleteImpl); 713 714 llvm::DenseSet<Selector> ClsMap; 715 // Check and see if class methods in category interface have been 716 // implemented in its implementation class. 717 for (ObjCCategoryImplDecl::classmeth_iterator 718 I = CatImplDecl->classmeth_begin(), E = CatImplDecl->classmeth_end(); 719 I != E; ++I) 720 ClsMap.insert((*I)->getSelector()); 721 722 for (ObjCCategoryDecl::classmeth_iterator I = CatClassDecl->classmeth_begin(), 723 E = CatClassDecl->classmeth_end(); I != E; ++I) 724 if (!ClsMap.count((*I)->getSelector())) 725 WarnUndefinedMethod(CatImplDecl->getLocation(), *I, IncompleteImpl); 726 727 // Check the protocol list for unimplemented methods in the @implementation 728 // class. 729 for (ObjCCategoryDecl::protocol_iterator PI = CatClassDecl->protocol_begin(), 730 E = CatClassDecl->protocol_end(); PI != E; ++PI) 731 CheckProtocolMethodDefs(CatImplDecl->getLocation(), *PI, IncompleteImpl, 732 InsMap, ClsMap, CatClassDecl->getClassInterface()); 733} 734 735/// ActOnForwardClassDeclaration - 736Action::DeclTy * 737Sema::ActOnForwardClassDeclaration(SourceLocation AtClassLoc, 738 IdentifierInfo **IdentList, unsigned NumElts) 739{ 740 llvm::SmallVector<ObjCInterfaceDecl*, 32> Interfaces; 741 742 for (unsigned i = 0; i != NumElts; ++i) { 743 // Check for another declaration kind with the same name. 744 Decl *PrevDecl = LookupDecl(IdentList[i], Decl::IDNS_Ordinary, TUScope); 745 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) { 746 // GCC apparently allows the following idiom: 747 // 748 // typedef NSObject < XCElementTogglerP > XCElementToggler; 749 // @class XCElementToggler; 750 // 751 // FIXME: Make an extension? 752 TypedefDecl *TDD = dyn_cast<TypedefDecl>(PrevDecl); 753 if (!TDD || !isa<ObjCInterfaceType>(TDD->getUnderlyingType())) { 754 Diag(AtClassLoc, diag::err_redefinition_different_kind) << IdentList[i]; 755 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 756 } 757 } 758 ObjCInterfaceDecl *IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl); 759 if (!IDecl) { // Not already seen? Make a forward decl. 760 IDecl = ObjCInterfaceDecl::Create(Context, AtClassLoc, IdentList[i], 761 SourceLocation(), true); 762 ObjCInterfaceDecls[IdentList[i]] = IDecl; 763 764 // Remember that this needs to be removed when the scope is popped. 765 TUScope->AddDecl(IDecl); 766 } 767 768 Interfaces.push_back(IDecl); 769 } 770 771 ObjCClassDecl *CDecl = ObjCClassDecl::Create(Context, AtClassLoc, 772 &Interfaces[0], 773 Interfaces.size()); 774 775 CheckObjCDeclScope(CDecl); 776 return CDecl; 777} 778 779 780/// MatchTwoMethodDeclarations - Checks that two methods have matching type and 781/// returns true, or false, accordingly. 782/// TODO: Handle protocol list; such as id<p1,p2> in type comparisons 783bool Sema::MatchTwoMethodDeclarations(const ObjCMethodDecl *Method, 784 const ObjCMethodDecl *PrevMethod, 785 bool matchBasedOnSizeAndAlignment) { 786 QualType T1 = Context.getCanonicalType(Method->getResultType()); 787 QualType T2 = Context.getCanonicalType(PrevMethod->getResultType()); 788 789 if (T1 != T2) { 790 // The result types are different. 791 if (!matchBasedOnSizeAndAlignment) 792 return false; 793 // Incomplete types don't have a size and alignment. 794 if (T1->isIncompleteType() || T2->isIncompleteType()) 795 return false; 796 // Check is based on size and alignment. 797 if (Context.getTypeInfo(T1) != Context.getTypeInfo(T2)) 798 return false; 799 } 800 for (unsigned i = 0, e = Method->getNumParams(); i != e; ++i) { 801 T1 = Context.getCanonicalType(Method->getParamDecl(i)->getType()); 802 T2 = Context.getCanonicalType(PrevMethod->getParamDecl(i)->getType()); 803 if (T1 != T2) { 804 // The result types are different. 805 if (!matchBasedOnSizeAndAlignment) 806 return false; 807 // Incomplete types don't have a size and alignment. 808 if (T1->isIncompleteType() || T2->isIncompleteType()) 809 return false; 810 // Check is based on size and alignment. 811 if (Context.getTypeInfo(T1) != Context.getTypeInfo(T2)) 812 return false; 813 } 814 } 815 return true; 816} 817 818void Sema::AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method) { 819 ObjCMethodList &FirstMethod = InstanceMethodPool[Method->getSelector()]; 820 if (!FirstMethod.Method) { 821 // Haven't seen a method with this selector name yet - add it. 822 FirstMethod.Method = Method; 823 FirstMethod.Next = 0; 824 } else { 825 // We've seen a method with this name, now check the type signature(s). 826 bool match = MatchTwoMethodDeclarations(Method, FirstMethod.Method); 827 828 for (ObjCMethodList *Next = FirstMethod.Next; !match && Next; 829 Next = Next->Next) 830 match = MatchTwoMethodDeclarations(Method, Next->Method); 831 832 if (!match) { 833 // We have a new signature for an existing method - add it. 834 // This is extremely rare. Only 1% of Cocoa selectors are "overloaded". 835 FirstMethod.Next = new ObjCMethodList(Method, FirstMethod.Next);; 836 } 837 } 838} 839 840// FIXME: Finish implementing -Wno-strict-selector-match. 841ObjCMethodDecl *Sema::LookupInstanceMethodInGlobalPool(Selector Sel, 842 SourceRange R) { 843 ObjCMethodList &MethList = InstanceMethodPool[Sel]; 844 bool issueWarning = false; 845 846 if (MethList.Method && MethList.Next) { 847 for (ObjCMethodList *Next = MethList.Next; Next; Next = Next->Next) 848 // This checks if the methods differ by size & alignment. 849 if (!MatchTwoMethodDeclarations(MethList.Method, Next->Method, true)) 850 issueWarning = true; 851 } 852 if (issueWarning && (MethList.Method && MethList.Next)) { 853 Diag(R.getBegin(), diag::warn_multiple_method_decl) << Sel << R; 854 Diag(MethList.Method->getLocStart(), diag::note_using_decl) 855 << MethList.Method->getSourceRange(); 856 for (ObjCMethodList *Next = MethList.Next; Next; Next = Next->Next) 857 Diag(Next->Method->getLocStart(), diag::note_also_found_decl) 858 << Next->Method->getSourceRange(); 859 } 860 return MethList.Method; 861} 862 863void Sema::AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method) { 864 ObjCMethodList &FirstMethod = FactoryMethodPool[Method->getSelector()]; 865 if (!FirstMethod.Method) { 866 // Haven't seen a method with this selector name yet - add it. 867 FirstMethod.Method = Method; 868 FirstMethod.Next = 0; 869 } else { 870 // We've seen a method with this name, now check the type signature(s). 871 bool match = MatchTwoMethodDeclarations(Method, FirstMethod.Method); 872 873 for (ObjCMethodList *Next = FirstMethod.Next; !match && Next; 874 Next = Next->Next) 875 match = MatchTwoMethodDeclarations(Method, Next->Method); 876 877 if (!match) { 878 // We have a new signature for an existing method - add it. 879 // This is extremely rare. Only 1% of Cocoa selectors are "overloaded". 880 struct ObjCMethodList *OMI = new ObjCMethodList(Method, FirstMethod.Next); 881 FirstMethod.Next = OMI; 882 } 883 } 884} 885 886/// diagnosePropertySetterGetterMismatch - Make sure that use-defined 887/// setter/getter methods have the property type and issue diagnostics 888/// if they don't. 889/// 890void 891Sema::diagnosePropertySetterGetterMismatch(ObjCPropertyDecl *property, 892 const ObjCMethodDecl *GetterMethod, 893 const ObjCMethodDecl *SetterMethod) { 894 if (GetterMethod && 895 GetterMethod->getResultType() != property->getType()) 896 Diag(property->getLocation(), 897 diag::err_accessor_property_type_mismatch) 898 << property->getDeclName() 899 << GetterMethod->getSelector().getAsIdentifierInfo(); 900 901 if (SetterMethod) { 902 if (SetterMethod->getResultType() != Context.VoidPtrTy) 903 Diag(SetterMethod->getLocation(), diag::err_setter_type_void); 904 if (SetterMethod->getNumParams() != 1 || 905 (SetterMethod->getParamDecl(0)->getType() != property->getType())) 906 Diag(property->getLocation(), 907 diag::err_accessor_property_type_mismatch) 908 << property->getDeclName() 909 << SetterMethod->getSelector().getAsIdentifierInfo(); 910 } 911} 912 913// Note: For class/category implemenations, allMethods/allProperties is 914// always null. 915void Sema::ActOnAtEnd(SourceLocation AtEndLoc, DeclTy *classDecl, 916 DeclTy **allMethods, unsigned allNum, 917 DeclTy **allProperties, unsigned pNum) { 918 Decl *ClassDecl = static_cast<Decl *>(classDecl); 919 920 // FIXME: If we don't have a ClassDecl, we have an error. We should consider 921 // always passing in a decl. If the decl has an error, isInvalidDecl() 922 // should be true. 923 if (!ClassDecl) 924 return; 925 926 llvm::SmallVector<ObjCMethodDecl*, 32> insMethods; 927 llvm::SmallVector<ObjCMethodDecl*, 16> clsMethods; 928 929 llvm::DenseMap<Selector, const ObjCMethodDecl*> InsMap; 930 llvm::DenseMap<Selector, const ObjCMethodDecl*> ClsMap; 931 932 bool isInterfaceDeclKind = 933 isa<ObjCInterfaceDecl>(ClassDecl) || isa<ObjCCategoryDecl>(ClassDecl) 934 || isa<ObjCProtocolDecl>(ClassDecl); 935 bool checkIdenticalMethods = isa<ObjCImplementationDecl>(ClassDecl); 936 937 if (pNum != 0) { 938 if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) 939 IDecl->addProperties((ObjCPropertyDecl**)allProperties, pNum); 940 else if (ObjCCategoryDecl *CDecl = dyn_cast<ObjCCategoryDecl>(ClassDecl)) 941 CDecl->addProperties((ObjCPropertyDecl**)allProperties, pNum); 942 else if (ObjCProtocolDecl *PDecl = dyn_cast<ObjCProtocolDecl>(ClassDecl)) 943 PDecl->addProperties((ObjCPropertyDecl**)allProperties, pNum); 944 else 945 assert(false && "ActOnAtEnd - property declaration misplaced"); 946 } 947 948 for (unsigned i = 0; i < allNum; i++ ) { 949 ObjCMethodDecl *Method = 950 cast_or_null<ObjCMethodDecl>(static_cast<Decl*>(allMethods[i])); 951 952 if (!Method) continue; // Already issued a diagnostic. 953 if (Method->isInstance()) { 954 /// Check for instance method of the same name with incompatible types 955 const ObjCMethodDecl *&PrevMethod = InsMap[Method->getSelector()]; 956 bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod) 957 : false; 958 if (isInterfaceDeclKind && PrevMethod && !match 959 || checkIdenticalMethods && match) { 960 Diag(Method->getLocation(), diag::err_duplicate_method_decl) 961 << Method->getDeclName(); 962 Diag(PrevMethod->getLocation(), diag::note_previous_declaration); 963 } else { 964 insMethods.push_back(Method); 965 InsMap[Method->getSelector()] = Method; 966 /// The following allows us to typecheck messages to "id". 967 AddInstanceMethodToGlobalPool(Method); 968 } 969 } 970 else { 971 /// Check for class method of the same name with incompatible types 972 const ObjCMethodDecl *&PrevMethod = ClsMap[Method->getSelector()]; 973 bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod) 974 : false; 975 if (isInterfaceDeclKind && PrevMethod && !match 976 || checkIdenticalMethods && match) { 977 Diag(Method->getLocation(), diag::err_duplicate_method_decl) 978 << Method->getDeclName(); 979 Diag(PrevMethod->getLocation(), diag::note_previous_declaration); 980 } else { 981 clsMethods.push_back(Method); 982 ClsMap[Method->getSelector()] = Method; 983 /// The following allows us to typecheck messages to "Class". 984 AddFactoryMethodToGlobalPool(Method); 985 } 986 } 987 } 988 // Save the size so we can detect if we've added any property methods. 989 unsigned int insMethodsSizePriorToPropAdds = insMethods.size(); 990 unsigned int clsMethodsSizePriorToPropAdds = clsMethods.size(); 991 992 if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) { 993 // Compares properties declared in this class to those of its 994 // super class. 995 ComparePropertiesInBaseAndSuper(I); 996 MergeProtocolPropertiesIntoClass(I, I); 997 for (ObjCInterfaceDecl::classprop_iterator i = I->classprop_begin(), 998 e = I->classprop_end(); i != e; ++i) { 999 diagnosePropertySetterGetterMismatch((*i), InsMap[(*i)->getGetterName()], 1000 InsMap[(*i)->getSetterName()]); 1001 I->addPropertyMethods(Context, *i, insMethods, InsMap); 1002 } 1003 I->addMethods(&insMethods[0], insMethods.size(), 1004 &clsMethods[0], clsMethods.size(), AtEndLoc); 1005 1006 } else if (ObjCProtocolDecl *P = dyn_cast<ObjCProtocolDecl>(ClassDecl)) { 1007 for (ObjCProtocolDecl::classprop_iterator i = P->classprop_begin(), 1008 e = P->classprop_end(); i != e; ++i) { 1009 diagnosePropertySetterGetterMismatch((*i), InsMap[(*i)->getGetterName()], 1010 InsMap[(*i)->getSetterName()]); 1011 P->addPropertyMethods(Context, *i, insMethods, InsMap); 1012 } 1013 P->addMethods(&insMethods[0], insMethods.size(), 1014 &clsMethods[0], clsMethods.size(), AtEndLoc); 1015 } 1016 else if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(ClassDecl)) { 1017 // FIXME: Need to compare properties to those in interface? 1018 1019 // FIXME: If we merge properties into class we should probably 1020 // merge them into category as well? 1021 for (ObjCCategoryDecl::classprop_iterator i = C->classprop_begin(), 1022 e = C->classprop_end(); i != e; ++i) { 1023 diagnosePropertySetterGetterMismatch((*i), InsMap[(*i)->getGetterName()], 1024 InsMap[(*i)->getSetterName()]); 1025 C->addPropertyMethods(Context, *i, insMethods, InsMap); 1026 } 1027 C->addMethods(&insMethods[0], insMethods.size(), 1028 &clsMethods[0], clsMethods.size(), AtEndLoc); 1029 } 1030 else if (ObjCImplementationDecl *IC = 1031 dyn_cast<ObjCImplementationDecl>(ClassDecl)) { 1032 IC->setLocEnd(AtEndLoc); 1033 if (ObjCInterfaceDecl* IDecl = getObjCInterfaceDecl(IC->getIdentifier())) 1034 ImplMethodsVsClassMethods(IC, IDecl); 1035 } else { 1036 ObjCCategoryImplDecl* CatImplClass = cast<ObjCCategoryImplDecl>(ClassDecl); 1037 CatImplClass->setLocEnd(AtEndLoc); 1038 ObjCInterfaceDecl* IDecl = CatImplClass->getClassInterface(); 1039 // Find category interface decl and then check that all methods declared 1040 // in this interface are implemented in the category @implementation. 1041 if (IDecl) { 1042 for (ObjCCategoryDecl *Categories = IDecl->getCategoryList(); 1043 Categories; Categories = Categories->getNextClassCategory()) { 1044 if (Categories->getIdentifier() == CatImplClass->getIdentifier()) { 1045 ImplCategoryMethodsVsIntfMethods(CatImplClass, Categories); 1046 break; 1047 } 1048 } 1049 } 1050 } 1051 // Add any synthesized methods to the global pool. This allows us to 1052 // handle the following, which is supported by GCC (and part of the design). 1053 // 1054 // @interface Foo 1055 // @property double bar; 1056 // @end 1057 // 1058 // void thisIsUnfortunate() { 1059 // id foo; 1060 // double bar = [foo bar]; 1061 // } 1062 // 1063 if (insMethodsSizePriorToPropAdds < insMethods.size()) 1064 for (unsigned i = insMethodsSizePriorToPropAdds; i < insMethods.size(); i++) 1065 AddInstanceMethodToGlobalPool(insMethods[i]); 1066 if (clsMethodsSizePriorToPropAdds < clsMethods.size()) 1067 for (unsigned i = clsMethodsSizePriorToPropAdds; i < clsMethods.size(); i++) 1068 AddFactoryMethodToGlobalPool(clsMethods[i]); 1069} 1070 1071 1072/// CvtQTToAstBitMask - utility routine to produce an AST bitmask for 1073/// objective-c's type qualifier from the parser version of the same info. 1074static Decl::ObjCDeclQualifier 1075CvtQTToAstBitMask(ObjCDeclSpec::ObjCDeclQualifier PQTVal) { 1076 Decl::ObjCDeclQualifier ret = Decl::OBJC_TQ_None; 1077 if (PQTVal & ObjCDeclSpec::DQ_In) 1078 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_In); 1079 if (PQTVal & ObjCDeclSpec::DQ_Inout) 1080 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Inout); 1081 if (PQTVal & ObjCDeclSpec::DQ_Out) 1082 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Out); 1083 if (PQTVal & ObjCDeclSpec::DQ_Bycopy) 1084 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Bycopy); 1085 if (PQTVal & ObjCDeclSpec::DQ_Byref) 1086 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Byref); 1087 if (PQTVal & ObjCDeclSpec::DQ_Oneway) 1088 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Oneway); 1089 1090 return ret; 1091} 1092 1093Sema::DeclTy *Sema::ActOnMethodDeclaration( 1094 SourceLocation MethodLoc, SourceLocation EndLoc, 1095 tok::TokenKind MethodType, DeclTy *classDecl, 1096 ObjCDeclSpec &ReturnQT, TypeTy *ReturnType, 1097 Selector Sel, 1098 // optional arguments. The number of types/arguments is obtained 1099 // from the Sel.getNumArgs(). 1100 ObjCDeclSpec *ArgQT, TypeTy **ArgTypes, IdentifierInfo **ArgNames, 1101 AttributeList *AttrList, tok::ObjCKeywordKind MethodDeclKind, 1102 bool isVariadic) { 1103 Decl *ClassDecl = static_cast<Decl*>(classDecl); 1104 1105 // Make sure we can establish a context for the method. 1106 if (!ClassDecl) { 1107 Diag(MethodLoc, diag::error_missing_method_context); 1108 return 0; 1109 } 1110 QualType resultDeclType; 1111 1112 if (ReturnType) 1113 resultDeclType = QualType::getFromOpaquePtr(ReturnType); 1114 else // get the type for "id". 1115 resultDeclType = Context.getObjCIdType(); 1116 1117 ObjCMethodDecl* ObjCMethod = 1118 ObjCMethodDecl::Create(Context, MethodLoc, EndLoc, Sel, resultDeclType, 1119 ClassDecl, 1120 MethodType == tok::minus, isVariadic, 1121 false, 1122 MethodDeclKind == tok::objc_optional ? 1123 ObjCMethodDecl::Optional : 1124 ObjCMethodDecl::Required); 1125 1126 llvm::SmallVector<ParmVarDecl*, 16> Params; 1127 1128 for (unsigned i = 0; i < Sel.getNumArgs(); i++) { 1129 // FIXME: arg->AttrList must be stored too! 1130 QualType argType; 1131 1132 if (ArgTypes[i]) 1133 argType = QualType::getFromOpaquePtr(ArgTypes[i]); 1134 else 1135 argType = Context.getObjCIdType(); 1136 ParmVarDecl* Param = ParmVarDecl::Create(Context, ObjCMethod, 1137 SourceLocation(/*FIXME*/), 1138 ArgNames[i], argType, 1139 VarDecl::None, 0, 0); 1140 Param->setObjCDeclQualifier( 1141 CvtQTToAstBitMask(ArgQT[i].getObjCDeclQualifier())); 1142 Params.push_back(Param); 1143 } 1144 1145 ObjCMethod->setMethodParams(&Params[0], Sel.getNumArgs()); 1146 ObjCMethod->setObjCDeclQualifier( 1147 CvtQTToAstBitMask(ReturnQT.getObjCDeclQualifier())); 1148 const ObjCMethodDecl *PrevMethod = 0; 1149 1150 if (AttrList) 1151 ProcessDeclAttributeList(ObjCMethod, AttrList); 1152 1153 // For implementations (which can be very "coarse grain"), we add the 1154 // method now. This allows the AST to implement lookup methods that work 1155 // incrementally (without waiting until we parse the @end). It also allows 1156 // us to flag multiple declaration errors as they occur. 1157 if (ObjCImplementationDecl *ImpDecl = 1158 dyn_cast<ObjCImplementationDecl>(ClassDecl)) { 1159 if (MethodType == tok::minus) { 1160 PrevMethod = ImpDecl->getInstanceMethod(Sel); 1161 ImpDecl->addInstanceMethod(ObjCMethod); 1162 } else { 1163 PrevMethod = ImpDecl->getClassMethod(Sel); 1164 ImpDecl->addClassMethod(ObjCMethod); 1165 } 1166 } 1167 else if (ObjCCategoryImplDecl *CatImpDecl = 1168 dyn_cast<ObjCCategoryImplDecl>(ClassDecl)) { 1169 if (MethodType == tok::minus) { 1170 PrevMethod = CatImpDecl->getInstanceMethod(Sel); 1171 CatImpDecl->addInstanceMethod(ObjCMethod); 1172 } else { 1173 PrevMethod = CatImpDecl->getClassMethod(Sel); 1174 CatImpDecl->addClassMethod(ObjCMethod); 1175 } 1176 } 1177 if (PrevMethod) { 1178 // You can never have two method definitions with the same name. 1179 Diag(ObjCMethod->getLocation(), diag::err_duplicate_method_decl) 1180 << ObjCMethod->getDeclName(); 1181 Diag(PrevMethod->getLocation(), diag::note_previous_declaration); 1182 } 1183 return ObjCMethod; 1184} 1185 1186void Sema::CheckObjCPropertyAttributes(QualType PropertyTy, 1187 SourceLocation Loc, 1188 unsigned &Attributes) { 1189 // FIXME: Improve the reported location. 1190 1191 // readonly and readwrite conflict. 1192 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) && 1193 (Attributes & ObjCDeclSpec::DQ_PR_readwrite)) { 1194 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive) 1195 << "readonly" << "readwrite"; 1196 Attributes &= ~ObjCDeclSpec::DQ_PR_readonly; 1197 } 1198 1199 // Check for copy or retain on non-object types. 1200 if ((Attributes & (ObjCDeclSpec::DQ_PR_copy | ObjCDeclSpec::DQ_PR_retain)) && 1201 !Context.isObjCObjectPointerType(PropertyTy)) { 1202 Diag(Loc, diag::err_objc_property_requires_object) 1203 << (Attributes & ObjCDeclSpec::DQ_PR_copy ? "copy" : "retain"); 1204 Attributes &= ~(ObjCDeclSpec::DQ_PR_copy | ObjCDeclSpec::DQ_PR_retain); 1205 } 1206 1207 // Check for more than one of { assign, copy, retain }. 1208 if (Attributes & ObjCDeclSpec::DQ_PR_assign) { 1209 if (Attributes & ObjCDeclSpec::DQ_PR_copy) { 1210 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive) 1211 << "assign" << "copy"; 1212 Attributes &= ~ObjCDeclSpec::DQ_PR_copy; 1213 } 1214 if (Attributes & ObjCDeclSpec::DQ_PR_retain) { 1215 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive) 1216 << "assign" << "retain"; 1217 Attributes &= ~ObjCDeclSpec::DQ_PR_retain; 1218 } 1219 } else if (Attributes & ObjCDeclSpec::DQ_PR_copy) { 1220 if (Attributes & ObjCDeclSpec::DQ_PR_retain) { 1221 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive) 1222 << "copy" << "retain"; 1223 Attributes &= ~ObjCDeclSpec::DQ_PR_retain; 1224 } 1225 } 1226 1227 // Warn if user supplied no assignment attribute, property is 1228 // readwrite, and this is an object type. 1229 if (!(Attributes & (ObjCDeclSpec::DQ_PR_assign | ObjCDeclSpec::DQ_PR_copy | 1230 ObjCDeclSpec::DQ_PR_retain)) && 1231 !(Attributes & ObjCDeclSpec::DQ_PR_readonly) && 1232 Context.isObjCObjectPointerType(PropertyTy)) { 1233 // Skip this warning in gc-only mode. 1234 if (getLangOptions().getGCMode() != LangOptions::GCOnly) 1235 Diag(Loc, diag::warn_objc_property_no_assignment_attribute); 1236 1237 // If non-gc code warn that this is likely inappropriate. 1238 if (getLangOptions().getGCMode() == LangOptions::NonGC) 1239 Diag(Loc, diag::warn_objc_property_default_assign_on_object); 1240 1241 // FIXME: Implement warning dependent on NSCopying being 1242 // implemented. See also: 1243 // <rdar://5168496&4855821&5607453&5096644&4947311&5698469&4947014&5168496> 1244 // (please trim this list while you are at it). 1245 } 1246} 1247 1248Sema::DeclTy *Sema::ActOnProperty(Scope *S, SourceLocation AtLoc, 1249 FieldDeclarator &FD, 1250 ObjCDeclSpec &ODS, 1251 Selector GetterSel, 1252 Selector SetterSel, 1253 DeclTy *ClassCategory, 1254 bool *isOverridingProperty, 1255 tok::ObjCKeywordKind MethodImplKind) { 1256 unsigned Attributes = ODS.getPropertyAttributes(); 1257 bool isReadWrite = ((Attributes & ObjCDeclSpec::DQ_PR_readwrite) || 1258 // default is readwrite! 1259 !(Attributes & ObjCDeclSpec::DQ_PR_readonly)); 1260 // property is defaulted to 'assign' if it is readwrite and is 1261 // not retain or copy 1262 bool isAssign = ((Attributes & ObjCDeclSpec::DQ_PR_assign) || 1263 (isReadWrite && 1264 !(Attributes & ObjCDeclSpec::DQ_PR_retain) && 1265 !(Attributes & ObjCDeclSpec::DQ_PR_copy))); 1266 QualType T = GetTypeForDeclarator(FD.D, S); 1267 Decl *ClassDecl = static_cast<Decl *>(ClassCategory); 1268 1269 // May modify Attributes. 1270 CheckObjCPropertyAttributes(T, AtLoc, Attributes); 1271 1272 if (ObjCCategoryDecl *CDecl = dyn_cast<ObjCCategoryDecl>(ClassDecl)) 1273 if (!CDecl->getIdentifier()) { 1274 // This is an anonymous category. property requires special 1275 // handling. 1276 if (ObjCInterfaceDecl *ICDecl = CDecl->getClassInterface()) { 1277 if (ObjCPropertyDecl *PIDecl = 1278 ICDecl->FindPropertyDeclaration(FD.D.getIdentifier())) { 1279 // property 'PIDecl's readonly attribute will be over-ridden 1280 // with anonymous category's readwrite property attribute! 1281 unsigned PIkind = PIDecl->getPropertyAttributes(); 1282 if (isReadWrite && (PIkind & ObjCPropertyDecl::OBJC_PR_readonly)) { 1283 if ((Attributes & ObjCPropertyDecl::OBJC_PR_retain) != 1284 (PIkind & ObjCPropertyDecl::OBJC_PR_retain) || 1285 (Attributes & ObjCPropertyDecl::OBJC_PR_copy) != 1286 (PIkind & ObjCPropertyDecl::OBJC_PR_copy) || 1287 (Attributes & ObjCPropertyDecl::OBJC_PR_nonatomic) != 1288 (PIkind & ObjCPropertyDecl::OBJC_PR_nonatomic)) 1289 Diag(AtLoc, diag::warn_property_attr_mismatch); 1290 PIDecl->makeitReadWriteAttribute(); 1291 if (Attributes & ObjCDeclSpec::DQ_PR_retain) 1292 PIDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_retain); 1293 if (Attributes & ObjCDeclSpec::DQ_PR_copy) 1294 PIDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_copy); 1295 PIDecl->setSetterName(SetterSel); 1296 // FIXME: use a common routine with addPropertyMethods. 1297 ObjCMethodDecl *SetterDecl = 1298 ObjCMethodDecl::Create(Context, AtLoc, AtLoc, SetterSel, 1299 Context.VoidTy, 1300 ICDecl, 1301 true, false, true, 1302 ObjCMethodDecl::Required); 1303 ParmVarDecl *Argument = ParmVarDecl::Create(Context, 1304 SetterDecl, 1305 SourceLocation(), 1306 FD.D.getIdentifier(), 1307 T, 1308 VarDecl::None, 1309 0, 0); 1310 SetterDecl->setMethodParams(&Argument, 1); 1311 PIDecl->setSetterMethodDecl(SetterDecl); 1312 } 1313 else 1314 Diag(AtLoc, diag::err_use_continuation_class) << ICDecl->getDeclName(); 1315 *isOverridingProperty = true; 1316 return 0; 1317 } 1318 // No matching property found in the main class. Just fall thru 1319 // and add property to the anonymous category. It looks like 1320 // it works as is. This category becomes just like a category 1321 // for its primary class. 1322 } else { 1323 Diag(CDecl->getLocation(), diag::err_continuation_class); 1324 *isOverridingProperty = true; 1325 return 0; 1326 } 1327 } 1328 1329 ObjCPropertyDecl *PDecl = ObjCPropertyDecl::Create(Context, AtLoc, 1330 FD.D.getIdentifier(), T); 1331 // Regardless of setter/getter attribute, we save the default getter/setter 1332 // selector names in anticipation of declaration of setter/getter methods. 1333 PDecl->setGetterName(GetterSel); 1334 PDecl->setSetterName(SetterSel); 1335 1336 if (Attributes & ObjCDeclSpec::DQ_PR_readonly) 1337 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readonly); 1338 1339 if (Attributes & ObjCDeclSpec::DQ_PR_getter) 1340 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_getter); 1341 1342 if (Attributes & ObjCDeclSpec::DQ_PR_setter) 1343 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_setter); 1344 1345 if (isReadWrite) 1346 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readwrite); 1347 1348 if (Attributes & ObjCDeclSpec::DQ_PR_retain) 1349 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_retain); 1350 1351 if (Attributes & ObjCDeclSpec::DQ_PR_copy) 1352 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_copy); 1353 1354 if (isAssign) 1355 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_assign); 1356 1357 if (Attributes & ObjCDeclSpec::DQ_PR_nonatomic) 1358 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_nonatomic); 1359 1360 if (MethodImplKind == tok::objc_required) 1361 PDecl->setPropertyImplementation(ObjCPropertyDecl::Required); 1362 else if (MethodImplKind == tok::objc_optional) 1363 PDecl->setPropertyImplementation(ObjCPropertyDecl::Optional); 1364 1365 return PDecl; 1366} 1367 1368/// ActOnPropertyImplDecl - This routine performs semantic checks and 1369/// builds the AST node for a property implementation declaration; declared 1370/// as @synthesize or @dynamic. 1371/// 1372Sema::DeclTy *Sema::ActOnPropertyImplDecl(SourceLocation AtLoc, 1373 SourceLocation PropertyLoc, 1374 bool Synthesize, 1375 DeclTy *ClassCatImpDecl, 1376 IdentifierInfo *PropertyId, 1377 IdentifierInfo *PropertyIvar) { 1378 Decl *ClassImpDecl = static_cast<Decl*>(ClassCatImpDecl); 1379 // Make sure we have a context for the property implementation declaration. 1380 if (!ClassImpDecl) { 1381 Diag(AtLoc, diag::error_missing_property_context); 1382 return 0; 1383 } 1384 ObjCPropertyDecl *property = 0; 1385 ObjCInterfaceDecl* IDecl = 0; 1386 // Find the class or category class where this property must have 1387 // a declaration. 1388 ObjCImplementationDecl *IC = 0; 1389 ObjCCategoryImplDecl* CatImplClass = 0; 1390 if ((IC = dyn_cast<ObjCImplementationDecl>(ClassImpDecl))) { 1391 IDecl = getObjCInterfaceDecl(IC->getIdentifier()); 1392 // We always synthesize an interface for an implementation 1393 // without an interface decl. So, IDecl is always non-zero. 1394 assert(IDecl && 1395 "ActOnPropertyImplDecl - @implementation without @interface"); 1396 1397 // Look for this property declaration in the @implementation's @interface 1398 property = IDecl->FindPropertyDeclaration(PropertyId); 1399 if (!property) { 1400 Diag(PropertyLoc, diag::error_bad_property_decl) << IDecl->getDeclName(); 1401 return 0; 1402 } 1403 } 1404 else if ((CatImplClass = dyn_cast<ObjCCategoryImplDecl>(ClassImpDecl))) { 1405 if (Synthesize) { 1406 Diag(AtLoc, diag::error_synthesize_category_decl); 1407 return 0; 1408 } 1409 IDecl = CatImplClass->getClassInterface(); 1410 if (!IDecl) { 1411 Diag(AtLoc, diag::error_missing_property_interface); 1412 return 0; 1413 } 1414 ObjCCategoryDecl *Category = 1415 IDecl->FindCategoryDeclaration(CatImplClass->getIdentifier()); 1416 1417 // If category for this implementation not found, it is an error which 1418 // has already been reported eralier. 1419 if (!Category) 1420 return 0; 1421 // Look for this property declaration in @implementation's category 1422 property = Category->FindPropertyDeclaration(PropertyId); 1423 if (!property) { 1424 Diag(PropertyLoc, diag::error_bad_category_property_decl) 1425 << Category->getDeclName(); 1426 return 0; 1427 } 1428 } 1429 else { 1430 Diag(AtLoc, diag::error_bad_property_context); 1431 return 0; 1432 } 1433 ObjCIvarDecl *Ivar = 0; 1434 // Check that we have a valid, previously declared ivar for @synthesize 1435 if (Synthesize) { 1436 // @synthesize 1437 if (!PropertyIvar) 1438 PropertyIvar = PropertyId; 1439 // Check that this is a previously declared 'ivar' in 'IDecl' interface 1440 Ivar = IDecl->FindIvarDeclaration(PropertyIvar); 1441 if (!Ivar) { 1442 Diag(PropertyLoc, diag::error_missing_property_ivar_decl) << PropertyId; 1443 return 0; 1444 } 1445 QualType PropType = Context.getCanonicalType(property->getType()); 1446 QualType IvarType = Context.getCanonicalType(Ivar->getType()); 1447 1448 // Check that type of property and its ivar are type compatible. 1449 if (PropType != IvarType) { 1450 if (CheckAssignmentConstraints(PropType, IvarType) != Compatible) { 1451 Diag(PropertyLoc, diag::error_property_ivar_type) 1452 << property->getDeclName() << Ivar->getDeclName(); 1453 return 0; 1454 } 1455 } 1456 } else if (PropertyIvar) { 1457 // @dynamic 1458 Diag(PropertyLoc, diag::error_dynamic_property_ivar_decl); 1459 return 0; 1460 } 1461 assert (property && "ActOnPropertyImplDecl - property declaration missing"); 1462 ObjCPropertyImplDecl *PIDecl = 1463 ObjCPropertyImplDecl::Create(Context, AtLoc, PropertyLoc, property, 1464 (Synthesize ? 1465 ObjCPropertyImplDecl::Synthesize 1466 : ObjCPropertyImplDecl::Dynamic), 1467 Ivar); 1468 if (IC) 1469 IC->addPropertyImplementation(PIDecl); 1470 else 1471 CatImplClass->addPropertyImplementation(PIDecl); 1472 1473 return PIDecl; 1474} 1475 1476bool Sema::CheckObjCDeclScope(Decl *D) 1477{ 1478 if (isa<TranslationUnitDecl>(CurContext)) 1479 return false; 1480 1481 Diag(D->getLocation(), diag::err_objc_decls_may_only_appear_in_global_scope); 1482 D->setInvalidDecl(); 1483 1484 return true; 1485} 1486