SemaDeclObjC.cpp revision 95256e68125fda8550bf9363fd77de1bd414ea48
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/Scope.h" 18 19using namespace clang; 20 21/// ObjCActOnStartOfMethodDef - This routine sets up parameters; invisible 22/// and user declared, in the method definition's AST. 23void Sema::ObjCActOnStartOfMethodDef(Scope *FnBodyScope, DeclTy *D) { 24 assert(getCurMethodDecl() == 0 && "Method parsing confused"); 25 ObjCMethodDecl *MDecl = dyn_cast<ObjCMethodDecl>(static_cast<Decl *>(D)); 26 assert(MDecl != 0 && "Not a method declarator!"); 27 28 // Allow the rest of sema to find private method decl implementations. 29 if (MDecl->isInstance()) 30 AddInstanceMethodToGlobalPool(MDecl); 31 else 32 AddFactoryMethodToGlobalPool(MDecl); 33 34 // Allow all of Sema to see that we are entering a method definition. 35 PushDeclContext(MDecl); 36 37 // Create Decl objects for each parameter, entrring them in the scope for 38 // binding to their use. 39 struct DeclaratorChunk::ParamInfo PI; 40 41 // Insert the invisible arguments, self and _cmd! 42 PI.Ident = &Context.Idents.get("self"); 43 PI.IdentLoc = SourceLocation(); // synthesized vars have a null location. 44 QualType selfTy; 45 if (MDecl->isInstance()) { 46 selfTy = Context.getObjCIdType(); 47 if (ObjCInterfaceDecl *OID = MDecl->getClassInterface()) { 48 // There may be no interface context due to error in declaration of the 49 // interface (which has been reported). Recover gracefully 50 selfTy = Context.getObjCInterfaceType(OID); 51 selfTy = Context.getPointerType(selfTy); 52 } 53 } else // we have a factory method. 54 selfTy = Context.getObjCClassType(); 55 getCurMethodDecl()->setSelfDecl(CreateImplicitParameter(FnBodyScope, 56 PI.Ident, PI.IdentLoc, selfTy)); 57 58 PI.Ident = &Context.Idents.get("_cmd"); 59 getCurMethodDecl()->setCmdDecl(CreateImplicitParameter(FnBodyScope, 60 PI.Ident, PI.IdentLoc, Context.getObjCSelType())); 61 62 // Introduce all of the other parameters into this scope. 63 for (unsigned i = 0, e = MDecl->getNumParams(); i != e; ++i) { 64 ParmVarDecl *PDecl = MDecl->getParamDecl(i); 65 IdentifierInfo *II = PDecl->getIdentifier(); 66 if (II) 67 PushOnScopeChains(PDecl, FnBodyScope); 68 } 69} 70 71Sema::DeclTy *Sema::ActOnStartClassInterface( 72 SourceLocation AtInterfaceLoc, 73 IdentifierInfo *ClassName, SourceLocation ClassLoc, 74 IdentifierInfo *SuperName, SourceLocation SuperLoc, 75 IdentifierInfo **ProtocolNames, unsigned NumProtocols, 76 SourceLocation EndProtoLoc, AttributeList *AttrList) { 77 assert(ClassName && "Missing class identifier"); 78 79 // Check for another declaration kind with the same name. 80 Decl *PrevDecl = LookupDecl(ClassName, Decl::IDNS_Ordinary, TUScope); 81 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) { 82 Diag(ClassLoc, diag::err_redefinition_different_kind, 83 ClassName->getName()); 84 Diag(PrevDecl->getLocation(), diag::err_previous_definition); 85 } 86 87 ObjCInterfaceDecl* IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl); 88 if (IDecl) { 89 // Class already seen. Is it a forward declaration? 90 if (!IDecl->isForwardDecl()) 91 Diag(AtInterfaceLoc, diag::err_duplicate_class_def, IDecl->getName()); 92 else { 93 IDecl->setLocation(AtInterfaceLoc); 94 IDecl->setForwardDecl(false); 95 IDecl->AllocIntfRefProtocols(NumProtocols); 96 } 97 } 98 else { 99 IDecl = ObjCInterfaceDecl::Create(Context, AtInterfaceLoc, NumProtocols, 100 ClassName, ClassLoc); 101 102 ObjCInterfaceDecls[ClassName] = IDecl; 103 // Remember that this needs to be removed when the scope is popped. 104 TUScope->AddDecl(IDecl); 105 } 106 107 if (SuperName) { 108 ObjCInterfaceDecl* SuperClassEntry = 0; 109 // Check if a different kind of symbol declared in this scope. 110 PrevDecl = LookupDecl(SuperName, Decl::IDNS_Ordinary, TUScope); 111 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) { 112 Diag(SuperLoc, diag::err_redefinition_different_kind, 113 SuperName->getName()); 114 Diag(PrevDecl->getLocation(), diag::err_previous_definition); 115 } 116 else { 117 // Check that super class is previously defined 118 SuperClassEntry = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl); 119 120 if (!SuperClassEntry || SuperClassEntry->isForwardDecl()) { 121 Diag(AtInterfaceLoc, diag::err_undef_superclass, 122 SuperClassEntry ? SuperClassEntry->getName() 123 : SuperName->getName(), 124 ClassName->getName()); 125 } 126 } 127 IDecl->setSuperClass(SuperClassEntry); 128 IDecl->setSuperClassLoc(SuperLoc); 129 IDecl->setLocEnd(SuperLoc); 130 } else { // we have a root class. 131 IDecl->setLocEnd(ClassLoc); 132 } 133 134 /// Check then save referenced protocols 135 if (NumProtocols) { 136 for (unsigned int i = 0; i != NumProtocols; i++) { 137 ObjCProtocolDecl* RefPDecl = ObjCProtocols[ProtocolNames[i]]; 138 if (!RefPDecl || RefPDecl->isForwardDecl()) 139 Diag(ClassLoc, diag::warn_undef_protocolref, 140 ProtocolNames[i]->getName(), 141 ClassName->getName()); 142 IDecl->setIntfRefProtocols(i, RefPDecl); 143 } 144 IDecl->setLocEnd(EndProtoLoc); 145 } 146 return IDecl; 147} 148 149/// ActOnCompatiblityAlias - this action is called after complete parsing of 150/// @compaatibility_alias declaration. It sets up the alias relationships. 151Sema::DeclTy *Sema::ActOnCompatiblityAlias(SourceLocation AtLoc, 152 IdentifierInfo *AliasName, 153 SourceLocation AliasLocation, 154 IdentifierInfo *ClassName, 155 SourceLocation ClassLocation) { 156 // Look for previous declaration of alias name 157 Decl *ADecl = LookupDecl(AliasName, Decl::IDNS_Ordinary, TUScope); 158 if (ADecl) { 159 if (isa<ObjCCompatibleAliasDecl>(ADecl)) { 160 Diag(AliasLocation, diag::warn_previous_alias_decl); 161 Diag(ADecl->getLocation(), diag::warn_previous_declaration); 162 } 163 else { 164 Diag(AliasLocation, diag::err_conflicting_aliasing_type, 165 AliasName->getName()); 166 Diag(ADecl->getLocation(), diag::err_previous_declaration); 167 } 168 return 0; 169 } 170 // Check for class declaration 171 Decl *CDeclU = LookupDecl(ClassName, Decl::IDNS_Ordinary, TUScope); 172 ObjCInterfaceDecl *CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(CDeclU); 173 if (CDecl == 0) { 174 Diag(ClassLocation, diag::warn_undef_interface, ClassName->getName()); 175 if (CDeclU) 176 Diag(CDeclU->getLocation(), diag::warn_previous_declaration); 177 return 0; 178 } 179 180 // Everything checked out, instantiate a new alias declaration AST. 181 ObjCCompatibleAliasDecl *AliasDecl = 182 ObjCCompatibleAliasDecl::Create(Context, AtLoc, AliasName, CDecl); 183 184 ObjCAliasDecls[AliasName] = AliasDecl; 185 TUScope->AddDecl(AliasDecl); 186 return AliasDecl; 187} 188 189Sema::DeclTy *Sema::ActOnStartProtocolInterface( 190 SourceLocation AtProtoInterfaceLoc, 191 IdentifierInfo *ProtocolName, SourceLocation ProtocolLoc, 192 IdentifierInfo **ProtoRefNames, unsigned NumProtoRefs, 193 SourceLocation EndProtoLoc) { 194 assert(ProtocolName && "Missing protocol identifier"); 195 ObjCProtocolDecl *PDecl = ObjCProtocols[ProtocolName]; 196 if (PDecl) { 197 // Protocol already seen. Better be a forward protocol declaration 198 if (!PDecl->isForwardDecl()) { 199 Diag(ProtocolLoc, diag::err_duplicate_protocol_def, 200 ProtocolName->getName()); 201 // Just return the protocol we already had. 202 // FIXME: don't leak the objects passed in! 203 return PDecl; 204 } 205 206 PDecl->setForwardDecl(false); 207 PDecl->AllocReferencedProtocols(NumProtoRefs); 208 } else { 209 PDecl = ObjCProtocolDecl::Create(Context, AtProtoInterfaceLoc, NumProtoRefs, 210 ProtocolName); 211 PDecl->setForwardDecl(false); 212 ObjCProtocols[ProtocolName] = PDecl; 213 } 214 215 if (NumProtoRefs) { 216 /// Check then save referenced protocols. 217 for (unsigned int i = 0; i != NumProtoRefs; i++) { 218 ObjCProtocolDecl* RefPDecl = ObjCProtocols[ProtoRefNames[i]]; 219 if (!RefPDecl || RefPDecl->isForwardDecl()) 220 Diag(ProtocolLoc, diag::warn_undef_protocolref, 221 ProtoRefNames[i]->getName(), 222 ProtocolName->getName()); 223 PDecl->setReferencedProtocols(i, RefPDecl); 224 } 225 PDecl->setLocEnd(EndProtoLoc); 226 } 227 return PDecl; 228} 229 230/// FindProtocolDeclaration - This routine looks up protocols and 231/// issuer error if they are not declared. It returns list of protocol 232/// declarations in its 'Protocols' argument. 233void 234Sema::FindProtocolDeclaration(SourceLocation TypeLoc, 235 IdentifierInfo **ProtocolId, 236 unsigned NumProtocols, 237 llvm::SmallVector<DeclTy *,8> &Protocols) { 238 for (unsigned i = 0; i != NumProtocols; ++i) { 239 ObjCProtocolDecl *PDecl = ObjCProtocols[ProtocolId[i]]; 240 if (!PDecl) 241 Diag(TypeLoc, diag::err_undeclared_protocol, 242 ProtocolId[i]->getName()); 243 else 244 Protocols.push_back(PDecl); 245 } 246} 247 248/// DiagnosePropertyMismatch - Compares two properties for their 249/// attributes and types and warns on a variety of inconsistancies. 250/// 251void 252Sema::DiagnosePropertyMismatch(ObjCPropertyDecl *Property, 253 ObjCPropertyDecl *SuperProperty, 254 const char *inheritedName) { 255 ObjCPropertyDecl::PropertyAttributeKind CAttr = 256 Property->getPropertyAttributes(); 257 ObjCPropertyDecl::PropertyAttributeKind SAttr = 258 SuperProperty->getPropertyAttributes(); 259 if ((CAttr & ObjCPropertyDecl::OBJC_PR_readonly) 260 && (SAttr & ObjCPropertyDecl::OBJC_PR_readwrite)) 261 Diag(Property->getLocation(), diag::warn_readonly_property, 262 Property->getName(), inheritedName); 263 if ((CAttr & ObjCPropertyDecl::OBJC_PR_copy) 264 != (SAttr & ObjCPropertyDecl::OBJC_PR_copy)) 265 Diag(Property->getLocation(), diag::warn_property_attribute, 266 Property->getName(), "copy", inheritedName, 267 SourceRange()); 268 else if ((CAttr & ObjCPropertyDecl::OBJC_PR_retain) 269 != (SAttr & ObjCPropertyDecl::OBJC_PR_retain)) 270 Diag(Property->getLocation(), diag::warn_property_attribute, 271 Property->getName(), "retain", inheritedName, 272 SourceRange()); 273 274 if ((CAttr & ObjCPropertyDecl::OBJC_PR_nonatomic) 275 != (SAttr & ObjCPropertyDecl::OBJC_PR_nonatomic)) 276 Diag(Property->getLocation(), diag::warn_property_attribute, 277 Property->getName(), "atomic", inheritedName, 278 SourceRange()); 279 if (Property->getSetterName() != SuperProperty->getSetterName()) 280 Diag(Property->getLocation(), diag::warn_property_attribute, 281 Property->getName(), "setter", inheritedName, 282 SourceRange()); 283 if (Property->getGetterName() != SuperProperty->getGetterName()) 284 Diag(Property->getLocation(), diag::warn_property_attribute, 285 Property->getName(), "getter", inheritedName, 286 SourceRange()); 287 288 if (Property->getCanonicalType() != SuperProperty->getCanonicalType()) 289 Diag(Property->getLocation(), diag::warn_property_type, 290 Property->getType().getAsString(), 291 inheritedName); 292 293} 294 295/// ComparePropertiesInBaseAndSuper - This routine compares property 296/// declarations in base and its super class, if any, and issues 297/// diagnostics in a variety of inconsistant situations. 298/// 299void 300Sema::ComparePropertiesInBaseAndSuper(ObjCInterfaceDecl *IDecl) { 301 ObjCInterfaceDecl *SDecl = IDecl->getSuperClass(); 302 if (!SDecl) 303 return; 304 for (ObjCInterfaceDecl::classprop_iterator S = SDecl->classprop_begin(), 305 E = SDecl->classprop_end(); S != E; ++S) { 306 ObjCPropertyDecl *SuperPDecl = (*S); 307 // Does property in super class has declaration in current class? 308 for (ObjCInterfaceDecl::classprop_iterator I = IDecl->classprop_begin(), 309 E = IDecl->classprop_end(); I != E; ++I) { 310 ObjCPropertyDecl *PDecl = (*I); 311 if (SuperPDecl->getIdentifier() == PDecl->getIdentifier()) 312 DiagnosePropertyMismatch(PDecl, SuperPDecl, SDecl->getName()); 313 } 314 } 315} 316 317/// MergeOneProtocolPropertiesIntoClass - This routine goes thru the list 318/// of properties declared in a protocol and adds them to the list 319/// of properties for current class if it is not there already. 320void 321Sema::MergeOneProtocolPropertiesIntoClass(ObjCInterfaceDecl *IDecl, 322 ObjCProtocolDecl *PDecl) 323{ 324 llvm::SmallVector<ObjCPropertyDecl*, 16> mergeProperties; 325 for (ObjCProtocolDecl::classprop_iterator P = PDecl->classprop_begin(), 326 E = PDecl->classprop_end(); P != E; ++P) { 327 ObjCPropertyDecl *Pr = (*P); 328 ObjCInterfaceDecl::classprop_iterator CP, CE; 329 // Is this property already in class's list of properties? 330 for (CP = IDecl->classprop_begin(), CE = IDecl->classprop_end(); 331 CP != CE; ++CP) 332 if ((*CP)->getIdentifier() == Pr->getIdentifier()) 333 break; 334 if (CP == CE) 335 // Add this property to list of properties for thie class. 336 mergeProperties.push_back(Pr); 337 else 338 // Property protocol already exist in class. Diagnose any mismatch. 339 DiagnosePropertyMismatch((*CP), Pr, PDecl->getName()); 340 } 341 IDecl->mergeProperties(&mergeProperties[0], mergeProperties.size()); 342} 343 344/// MergeProtocolPropertiesIntoClass - This routine merges properties 345/// declared in 'MergeItsProtocols' objects (which can be a class or an 346/// inherited protocol into the list of properties for class 'IDecl' 347/// 348 349void 350Sema::MergeProtocolPropertiesIntoClass(ObjCInterfaceDecl *IDecl, 351 DeclTy *MergeItsProtocols) { 352 Decl *ClassDecl = static_cast<Decl *>(MergeItsProtocols); 353 if (ObjCInterfaceDecl *MDecl = 354 dyn_cast<ObjCInterfaceDecl>(ClassDecl)) { 355 for (ObjCInterfaceDecl::protocol_iterator P = MDecl->protocol_begin(), 356 E = MDecl->protocol_end(); P != E; ++P) 357 MergeOneProtocolPropertiesIntoClass(IDecl, (*P)); 358 // Merge properties of class (*P) into IDECL's 359 ; 360 // Go thru the list of protocols for this class and recursively merge 361 // their properties into this class as well. 362 for (ObjCInterfaceDecl::protocol_iterator P = IDecl->protocol_begin(), 363 E = IDecl->protocol_end(); P != E; ++P) 364 MergeProtocolPropertiesIntoClass(IDecl, (*P)); 365 } 366 else if (ObjCProtocolDecl *MDecl = 367 dyn_cast<ObjCProtocolDecl>(ClassDecl)) 368 for (ObjCProtocolDecl::protocol_iterator P = MDecl->protocol_begin(), 369 E = MDecl->protocol_end(); P != E; ++P) 370 MergeOneProtocolPropertiesIntoClass(IDecl, (*P)); 371 else 372 assert(false && "MergeProtocolPropertiesIntoClass - bad object kind"); 373} 374 375/// ActOnForwardProtocolDeclaration - 376Action::DeclTy * 377Sema::ActOnForwardProtocolDeclaration(SourceLocation AtProtocolLoc, 378 IdentifierInfo **IdentList, unsigned NumElts) { 379 llvm::SmallVector<ObjCProtocolDecl*, 32> Protocols; 380 381 for (unsigned i = 0; i != NumElts; ++i) { 382 IdentifierInfo *Ident = IdentList[i]; 383 ObjCProtocolDecl *&PDecl = ObjCProtocols[Ident]; 384 if (PDecl == 0) { // Not already seen? 385 // FIXME: Pass in the location of the identifier! 386 PDecl = ObjCProtocolDecl::Create(Context, AtProtocolLoc, 0, Ident); 387 } 388 389 Protocols.push_back(PDecl); 390 } 391 return ObjCForwardProtocolDecl::Create(Context, AtProtocolLoc, 392 &Protocols[0], Protocols.size()); 393} 394 395Sema::DeclTy *Sema::ActOnStartCategoryInterface( 396 SourceLocation AtInterfaceLoc, 397 IdentifierInfo *ClassName, SourceLocation ClassLoc, 398 IdentifierInfo *CategoryName, SourceLocation CategoryLoc, 399 IdentifierInfo **ProtoRefNames, unsigned NumProtoRefs, 400 SourceLocation EndProtoLoc) { 401 ObjCInterfaceDecl *IDecl = getObjCInterfaceDecl(ClassName); 402 403 ObjCCategoryDecl *CDecl = 404 ObjCCategoryDecl::Create(Context, AtInterfaceLoc, CategoryName); 405 CDecl->setClassInterface(IDecl); 406 407 /// Check that class of this category is already completely declared. 408 if (!IDecl || IDecl->isForwardDecl()) 409 Diag(ClassLoc, diag::err_undef_interface, ClassName->getName()); 410 else { 411 /// Check for duplicate interface declaration for this category 412 ObjCCategoryDecl *CDeclChain; 413 for (CDeclChain = IDecl->getCategoryList(); CDeclChain; 414 CDeclChain = CDeclChain->getNextClassCategory()) { 415 if (CategoryName && CDeclChain->getIdentifier() == CategoryName) { 416 Diag(CategoryLoc, diag::warn_dup_category_def, ClassName->getName(), 417 CategoryName->getName()); 418 break; 419 } 420 } 421 if (!CDeclChain) 422 CDecl->insertNextClassCategory(); 423 } 424 425 if (NumProtoRefs) { 426 llvm::SmallVector<ObjCProtocolDecl*, 32> RefProtocols; 427 /// Check and then save the referenced protocols. 428 for (unsigned int i = 0; i != NumProtoRefs; i++) { 429 ObjCProtocolDecl* RefPDecl = ObjCProtocols[ProtoRefNames[i]]; 430 if (!RefPDecl || RefPDecl->isForwardDecl()) { 431 Diag(CategoryLoc, diag::warn_undef_protocolref, 432 ProtoRefNames[i]->getName(), 433 CategoryName->getName()); 434 } 435 if (RefPDecl) 436 RefProtocols.push_back(RefPDecl); 437 } 438 if (!RefProtocols.empty()) 439 CDecl->setReferencedProtocolList(&RefProtocols[0], RefProtocols.size()); 440 } 441 CDecl->setLocEnd(EndProtoLoc); 442 return CDecl; 443} 444 445/// ActOnStartCategoryImplementation - Perform semantic checks on the 446/// category implementation declaration and build an ObjCCategoryImplDecl 447/// object. 448Sema::DeclTy *Sema::ActOnStartCategoryImplementation( 449 SourceLocation AtCatImplLoc, 450 IdentifierInfo *ClassName, SourceLocation ClassLoc, 451 IdentifierInfo *CatName, SourceLocation CatLoc) { 452 ObjCInterfaceDecl *IDecl = getObjCInterfaceDecl(ClassName); 453 ObjCCategoryImplDecl *CDecl = 454 ObjCCategoryImplDecl::Create(Context, AtCatImplLoc, CatName, IDecl); 455 /// Check that class of this category is already completely declared. 456 if (!IDecl || IDecl->isForwardDecl()) 457 Diag(ClassLoc, diag::err_undef_interface, ClassName->getName()); 458 459 /// TODO: Check that CatName, category name, is not used in another 460 // implementation. 461 return CDecl; 462} 463 464Sema::DeclTy *Sema::ActOnStartClassImplementation( 465 SourceLocation AtClassImplLoc, 466 IdentifierInfo *ClassName, SourceLocation ClassLoc, 467 IdentifierInfo *SuperClassname, 468 SourceLocation SuperClassLoc) { 469 ObjCInterfaceDecl* IDecl = 0; 470 // Check for another declaration kind with the same name. 471 Decl *PrevDecl = LookupDecl(ClassName, Decl::IDNS_Ordinary, TUScope); 472 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) { 473 Diag(ClassLoc, diag::err_redefinition_different_kind, 474 ClassName->getName()); 475 Diag(PrevDecl->getLocation(), diag::err_previous_definition); 476 } 477 else { 478 // Is there an interface declaration of this class; if not, warn! 479 IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl); 480 if (!IDecl) 481 Diag(ClassLoc, diag::warn_undef_interface, ClassName->getName()); 482 } 483 484 // Check that super class name is valid class name 485 ObjCInterfaceDecl* SDecl = 0; 486 if (SuperClassname) { 487 // Check if a different kind of symbol declared in this scope. 488 PrevDecl = LookupDecl(SuperClassname, Decl::IDNS_Ordinary, TUScope); 489 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) { 490 Diag(SuperClassLoc, diag::err_redefinition_different_kind, 491 SuperClassname->getName()); 492 Diag(PrevDecl->getLocation(), diag::err_previous_definition); 493 } 494 else { 495 SDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl); 496 if (!SDecl) 497 Diag(SuperClassLoc, diag::err_undef_superclass, 498 SuperClassname->getName(), ClassName->getName()); 499 else if (IDecl && IDecl->getSuperClass() != SDecl) { 500 // This implementation and its interface do not have the same 501 // super class. 502 Diag(SuperClassLoc, diag::err_conflicting_super_class, 503 SDecl->getName()); 504 Diag(SDecl->getLocation(), diag::err_previous_definition); 505 } 506 } 507 } 508 509 if (!IDecl) { 510 // Legacy case of @implementation with no corresponding @interface. 511 // Build, chain & install the interface decl into the identifier. 512 IDecl = ObjCInterfaceDecl::Create(Context, AtClassImplLoc, 0, ClassName, 513 ClassLoc, false, true); 514 ObjCInterfaceDecls[ClassName] = IDecl; 515 IDecl->setSuperClass(SDecl); 516 IDecl->setLocEnd(ClassLoc); 517 518 // Remember that this needs to be removed when the scope is popped. 519 TUScope->AddDecl(IDecl); 520 } 521 522 ObjCImplementationDecl* IMPDecl = 523 ObjCImplementationDecl::Create(Context, AtClassImplLoc, ClassName, 524 IDecl, SDecl); 525 526 // Check that there is no duplicate implementation of this class. 527 if (ObjCImplementations[ClassName]) 528 // FIXME: Don't leak everything! 529 Diag(ClassLoc, diag::err_dup_implementation_class, ClassName->getName()); 530 else // add it to the list. 531 ObjCImplementations[ClassName] = IMPDecl; 532 return IMPDecl; 533} 534 535void Sema::CheckImplementationIvars(ObjCImplementationDecl *ImpDecl, 536 ObjCIvarDecl **ivars, unsigned numIvars, 537 SourceLocation RBrace) { 538 assert(ImpDecl && "missing implementation decl"); 539 ObjCInterfaceDecl* IDecl = getObjCInterfaceDecl(ImpDecl->getIdentifier()); 540 if (!IDecl) 541 return; 542 /// Check case of non-existing @interface decl. 543 /// (legacy objective-c @implementation decl without an @interface decl). 544 /// Add implementations's ivar to the synthesize class's ivar list. 545 if (IDecl->ImplicitInterfaceDecl()) { 546 IDecl->addInstanceVariablesToClass(ivars, numIvars, RBrace); 547 return; 548 } 549 // If implementation has empty ivar list, just return. 550 if (numIvars == 0) 551 return; 552 553 assert(ivars && "missing @implementation ivars"); 554 555 // Check interface's Ivar list against those in the implementation. 556 // names and types must match. 557 // 558 unsigned j = 0; 559 ObjCInterfaceDecl::ivar_iterator 560 IVI = IDecl->ivar_begin(), IVE = IDecl->ivar_end(); 561 for (; numIvars > 0 && IVI != IVE; ++IVI) { 562 ObjCIvarDecl* ImplIvar = ivars[j++]; 563 ObjCIvarDecl* ClsIvar = *IVI; 564 assert (ImplIvar && "missing implementation ivar"); 565 assert (ClsIvar && "missing class ivar"); 566 if (ImplIvar->getCanonicalType() != ClsIvar->getCanonicalType()) { 567 Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_type, 568 ImplIvar->getIdentifier()->getName()); 569 Diag(ClsIvar->getLocation(), diag::err_previous_definition, 570 ClsIvar->getIdentifier()->getName()); 571 } 572 // TODO: Two mismatched (unequal width) Ivar bitfields should be diagnosed 573 // as error. 574 else if (ImplIvar->getIdentifier() != ClsIvar->getIdentifier()) { 575 Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_name, 576 ImplIvar->getIdentifier()->getName()); 577 Diag(ClsIvar->getLocation(), diag::err_previous_definition, 578 ClsIvar->getIdentifier()->getName()); 579 return; 580 } 581 --numIvars; 582 } 583 584 if (numIvars > 0) 585 Diag(ivars[j]->getLocation(), diag::err_inconsistant_ivar_count); 586 else if (IVI != IVE) 587 Diag((*IVI)->getLocation(), diag::err_inconsistant_ivar_count); 588} 589 590void Sema::WarnUndefinedMethod(SourceLocation ImpLoc, ObjCMethodDecl *method, 591 bool &IncompleteImpl) { 592 if (!IncompleteImpl) { 593 Diag(ImpLoc, diag::warn_incomplete_impl); 594 IncompleteImpl = true; 595 } 596 Diag(ImpLoc, diag::warn_undef_method_impl, method->getSelector().getName()); 597} 598 599/// CheckProtocolMethodDefs - This routine checks unimplemented methods 600/// Declared in protocol, and those referenced by it. 601void Sema::CheckProtocolMethodDefs(SourceLocation ImpLoc, 602 ObjCProtocolDecl *PDecl, 603 bool& IncompleteImpl, 604 const llvm::DenseSet<Selector> &InsMap, 605 const llvm::DenseSet<Selector> &ClsMap) { 606 // check unimplemented instance methods. 607 for (ObjCProtocolDecl::instmeth_iterator I = PDecl->instmeth_begin(), 608 E = PDecl->instmeth_end(); I != E; ++I) { 609 ObjCMethodDecl *method = *I; 610 if (!InsMap.count(method->getSelector()) && 611 method->getImplementationControl() != ObjCMethodDecl::Optional) 612 WarnUndefinedMethod(ImpLoc, method, IncompleteImpl); 613 } 614 // check unimplemented class methods 615 for (ObjCProtocolDecl::classmeth_iterator I = PDecl->classmeth_begin(), 616 E = PDecl->classmeth_end(); I != E; ++I) { 617 ObjCMethodDecl *method = *I; 618 if (!ClsMap.count(method->getSelector()) && 619 method->getImplementationControl() != ObjCMethodDecl::Optional) 620 WarnUndefinedMethod(ImpLoc, method, IncompleteImpl); 621 } 622 // Check on this protocols's referenced protocols, recursively 623 ObjCProtocolDecl** RefPDecl = PDecl->getReferencedProtocols(); 624 for (unsigned i = 0; i < PDecl->getNumReferencedProtocols(); i++) 625 CheckProtocolMethodDefs(ImpLoc, RefPDecl[i], IncompleteImpl, InsMap, ClsMap); 626} 627 628void Sema::ImplMethodsVsClassMethods(ObjCImplementationDecl* IMPDecl, 629 ObjCInterfaceDecl* IDecl) { 630 llvm::DenseSet<Selector> InsMap; 631 // Check and see if instance methods in class interface have been 632 // implemented in the implementation class. 633 for (ObjCImplementationDecl::instmeth_iterator I = IMPDecl->instmeth_begin(), 634 E = IMPDecl->instmeth_end(); I != E; ++I) 635 InsMap.insert((*I)->getSelector()); 636 637 bool IncompleteImpl = false; 638 for (ObjCInterfaceDecl::instmeth_iterator I = IDecl->instmeth_begin(), 639 E = IDecl->instmeth_end(); I != E; ++I) 640 if (!(*I)->isSynthesized() && !InsMap.count((*I)->getSelector())) 641 WarnUndefinedMethod(IMPDecl->getLocation(), *I, IncompleteImpl); 642 643 llvm::DenseSet<Selector> ClsMap; 644 // Check and see if class methods in class interface have been 645 // implemented in the implementation class. 646 for (ObjCImplementationDecl::classmeth_iterator I =IMPDecl->classmeth_begin(), 647 E = IMPDecl->classmeth_end(); I != E; ++I) 648 ClsMap.insert((*I)->getSelector()); 649 650 for (ObjCInterfaceDecl::classmeth_iterator I = IDecl->classmeth_begin(), 651 E = IDecl->classmeth_end(); I != E; ++I) 652 if (!ClsMap.count((*I)->getSelector())) 653 WarnUndefinedMethod(IMPDecl->getLocation(), *I, IncompleteImpl); 654 655 // Check the protocol list for unimplemented methods in the @implementation 656 // class. 657 ObjCProtocolDecl** protocols = IDecl->getReferencedProtocols(); 658 for (unsigned i = 0; i < IDecl->getNumIntfRefProtocols(); i++) 659 CheckProtocolMethodDefs(IMPDecl->getLocation(), protocols[i], 660 IncompleteImpl, InsMap, ClsMap); 661} 662 663/// ImplCategoryMethodsVsIntfMethods - Checks that methods declared in the 664/// category interface is implemented in the category @implementation. 665void Sema::ImplCategoryMethodsVsIntfMethods(ObjCCategoryImplDecl *CatImplDecl, 666 ObjCCategoryDecl *CatClassDecl) { 667 llvm::DenseSet<Selector> InsMap; 668 // Check and see if instance methods in category interface have been 669 // implemented in its implementation class. 670 for (ObjCCategoryImplDecl::instmeth_iterator I =CatImplDecl->instmeth_begin(), 671 E = CatImplDecl->instmeth_end(); I != E; ++I) 672 InsMap.insert((*I)->getSelector()); 673 674 bool IncompleteImpl = false; 675 for (ObjCCategoryDecl::instmeth_iterator I = CatClassDecl->instmeth_begin(), 676 E = CatClassDecl->instmeth_end(); I != E; ++I) 677 if (!InsMap.count((*I)->getSelector())) 678 WarnUndefinedMethod(CatImplDecl->getLocation(), *I, IncompleteImpl); 679 680 llvm::DenseSet<Selector> ClsMap; 681 // Check and see if class methods in category interface have been 682 // implemented in its implementation class. 683 for (ObjCCategoryImplDecl::classmeth_iterator 684 I = CatImplDecl->classmeth_begin(), E = CatImplDecl->classmeth_end(); 685 I != E; ++I) 686 ClsMap.insert((*I)->getSelector()); 687 688 for (ObjCCategoryDecl::classmeth_iterator I = CatClassDecl->classmeth_begin(), 689 E = CatClassDecl->classmeth_end(); I != E; ++I) 690 if (!ClsMap.count((*I)->getSelector())) 691 WarnUndefinedMethod(CatImplDecl->getLocation(), *I, IncompleteImpl); 692 693 // Check the protocol list for unimplemented methods in the @implementation 694 // class. 695 ObjCProtocolDecl** protocols = CatClassDecl->getReferencedProtocols(); 696 for (unsigned i = 0; i < CatClassDecl->getNumReferencedProtocols(); i++) { 697 ObjCProtocolDecl* PDecl = protocols[i]; 698 CheckProtocolMethodDefs(CatImplDecl->getLocation(), PDecl, IncompleteImpl, 699 InsMap, ClsMap); 700 } 701} 702 703/// ActOnForwardClassDeclaration - 704Action::DeclTy * 705Sema::ActOnForwardClassDeclaration(SourceLocation AtClassLoc, 706 IdentifierInfo **IdentList, unsigned NumElts) 707{ 708 llvm::SmallVector<ObjCInterfaceDecl*, 32> Interfaces; 709 710 for (unsigned i = 0; i != NumElts; ++i) { 711 // Check for another declaration kind with the same name. 712 Decl *PrevDecl = LookupDecl(IdentList[i], Decl::IDNS_Ordinary, TUScope); 713 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) { 714 // GCC apparently allows the following idiom: 715 // 716 // typedef NSObject < XCElementTogglerP > XCElementToggler; 717 // @class XCElementToggler; 718 // 719 // FIXME: Make an extension? 720 TypedefDecl *TDD = dyn_cast<TypedefDecl>(PrevDecl); 721 if (!TDD || !isa<ObjCInterfaceType>(TDD->getUnderlyingType())) { 722 Diag(AtClassLoc, diag::err_redefinition_different_kind, 723 IdentList[i]->getName()); 724 Diag(PrevDecl->getLocation(), diag::err_previous_definition); 725 } 726 } 727 ObjCInterfaceDecl *IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl); 728 if (!IDecl) { // Not already seen? Make a forward decl. 729 IDecl = ObjCInterfaceDecl::Create(Context, AtClassLoc, 0, IdentList[i], 730 SourceLocation(), true); 731 ObjCInterfaceDecls[IdentList[i]] = IDecl; 732 733 // Remember that this needs to be removed when the scope is popped. 734 TUScope->AddDecl(IDecl); 735 } 736 737 Interfaces.push_back(IDecl); 738 } 739 740 return ObjCClassDecl::Create(Context, AtClassLoc, 741 &Interfaces[0], Interfaces.size()); 742} 743 744 745/// MatchTwoMethodDeclarations - Checks that two methods have matching type and 746/// returns true, or false, accordingly. 747/// TODO: Handle protocol list; such as id<p1,p2> in type comparisons 748bool Sema::MatchTwoMethodDeclarations(const ObjCMethodDecl *Method, 749 const ObjCMethodDecl *PrevMethod) { 750 if (Method->getResultType().getCanonicalType() != 751 PrevMethod->getResultType().getCanonicalType()) 752 return false; 753 for (unsigned i = 0, e = Method->getNumParams(); i != e; ++i) { 754 ParmVarDecl *ParamDecl = Method->getParamDecl(i); 755 ParmVarDecl *PrevParamDecl = PrevMethod->getParamDecl(i); 756 if (Context.getCanonicalType(ParamDecl->getType()) != 757 Context.getCanonicalType(PrevParamDecl->getType())) 758 return false; 759 } 760 return true; 761} 762 763void Sema::AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method) { 764 ObjCMethodList &FirstMethod = InstanceMethodPool[Method->getSelector()]; 765 if (!FirstMethod.Method) { 766 // Haven't seen a method with this selector name yet - add it. 767 FirstMethod.Method = Method; 768 FirstMethod.Next = 0; 769 } else { 770 // We've seen a method with this name, now check the type signature(s). 771 bool match = MatchTwoMethodDeclarations(Method, FirstMethod.Method); 772 773 for (ObjCMethodList *Next = FirstMethod.Next; !match && Next; 774 Next = Next->Next) 775 match = MatchTwoMethodDeclarations(Method, Next->Method); 776 777 if (!match) { 778 // We have a new signature for an existing method - add it. 779 // This is extremely rare. Only 1% of Cocoa selectors are "overloaded". 780 struct ObjCMethodList *OMI = new ObjCMethodList(Method, FirstMethod.Next); 781 FirstMethod.Next = OMI; 782 } 783 } 784} 785 786void Sema::AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method) { 787 ObjCMethodList &FirstMethod = FactoryMethodPool[Method->getSelector()]; 788 if (!FirstMethod.Method) { 789 // Haven't seen a method with this selector name yet - add it. 790 FirstMethod.Method = Method; 791 FirstMethod.Next = 0; 792 } else { 793 // We've seen a method with this name, now check the type signature(s). 794 bool match = MatchTwoMethodDeclarations(Method, FirstMethod.Method); 795 796 for (ObjCMethodList *Next = FirstMethod.Next; !match && Next; 797 Next = Next->Next) 798 match = MatchTwoMethodDeclarations(Method, Next->Method); 799 800 if (!match) { 801 // We have a new signature for an existing method - add it. 802 // This is extremely rare. Only 1% of Cocoa selectors are "overloaded". 803 struct ObjCMethodList *OMI = new ObjCMethodList(Method, FirstMethod.Next); 804 FirstMethod.Next = OMI; 805 } 806 } 807} 808 809// Note: For class/category implemenations, allMethods/allProperties is 810// always null. 811void Sema::ActOnAtEnd(SourceLocation AtEndLoc, DeclTy *classDecl, 812 DeclTy **allMethods, unsigned allNum, 813 DeclTy **allProperties, unsigned pNum) { 814 Decl *ClassDecl = static_cast<Decl *>(classDecl); 815 816 // FIXME: If we don't have a ClassDecl, we have an error. We should consider 817 // always passing in a decl. If the decl has an error, isInvalidDecl() 818 // should be true. 819 if (!ClassDecl) 820 return; 821 822 llvm::SmallVector<ObjCMethodDecl*, 32> insMethods; 823 llvm::SmallVector<ObjCMethodDecl*, 16> clsMethods; 824 825 llvm::DenseMap<Selector, const ObjCMethodDecl*> InsMap; 826 llvm::DenseMap<Selector, const ObjCMethodDecl*> ClsMap; 827 828 bool isInterfaceDeclKind = 829 isa<ObjCInterfaceDecl>(ClassDecl) || isa<ObjCCategoryDecl>(ClassDecl) 830 || isa<ObjCProtocolDecl>(ClassDecl); 831 bool checkIdenticalMethods = isa<ObjCImplementationDecl>(ClassDecl); 832 833 if (pNum != 0) 834 if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) 835 IDecl->addProperties((ObjCPropertyDecl**)allProperties, pNum); 836 else if (ObjCCategoryDecl *CDecl = dyn_cast<ObjCCategoryDecl>(ClassDecl)) 837 CDecl->addProperties((ObjCPropertyDecl**)allProperties, pNum); 838 else if (ObjCProtocolDecl *PDecl = dyn_cast<ObjCProtocolDecl>(ClassDecl)) 839 PDecl->addProperties((ObjCPropertyDecl**)allProperties, pNum); 840 else 841 assert(false && "ActOnAtEnd - property declaration misplaced"); 842 843 for (unsigned i = 0; i < allNum; i++ ) { 844 ObjCMethodDecl *Method = 845 cast_or_null<ObjCMethodDecl>(static_cast<Decl*>(allMethods[i])); 846 847 if (!Method) continue; // Already issued a diagnostic. 848 if (Method->isInstance()) { 849 /// Check for instance method of the same name with incompatible types 850 const ObjCMethodDecl *&PrevMethod = InsMap[Method->getSelector()]; 851 bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod) 852 : false; 853 if (isInterfaceDeclKind && PrevMethod && !match 854 || checkIdenticalMethods && match) { 855 Diag(Method->getLocation(), diag::error_duplicate_method_decl, 856 Method->getSelector().getName()); 857 Diag(PrevMethod->getLocation(), diag::err_previous_declaration); 858 } else { 859 insMethods.push_back(Method); 860 InsMap[Method->getSelector()] = Method; 861 /// The following allows us to typecheck messages to "id". 862 AddInstanceMethodToGlobalPool(Method); 863 } 864 } 865 else { 866 /// Check for class method of the same name with incompatible types 867 const ObjCMethodDecl *&PrevMethod = ClsMap[Method->getSelector()]; 868 bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod) 869 : false; 870 if (isInterfaceDeclKind && PrevMethod && !match 871 || checkIdenticalMethods && match) { 872 Diag(Method->getLocation(), diag::error_duplicate_method_decl, 873 Method->getSelector().getName()); 874 Diag(PrevMethod->getLocation(), diag::err_previous_declaration); 875 } else { 876 clsMethods.push_back(Method); 877 ClsMap[Method->getSelector()] = Method; 878 /// The following allows us to typecheck messages to "Class". 879 AddFactoryMethodToGlobalPool(Method); 880 } 881 } 882 } 883 884 if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) { 885 // Compares properties declaraed in this class to those of its 886 // super class. 887 ComparePropertiesInBaseAndSuper(I); 888 MergeProtocolPropertiesIntoClass(I, I); 889 for (ObjCInterfaceDecl::classprop_iterator P = I->classprop_begin(), 890 E = I->classprop_end(); P != E; ++P) { 891 // FIXME: It would be really nice if we could avoid this. Injecting 892 // methods into the interface makes it hard to distinguish "real" methods 893 // from synthesized "property" methods (that aren't in the source). 894 // This complicicates the rewriter's life. 895 I->addPropertyMethods(Context, *P, insMethods); 896 } 897 I->addMethods(&insMethods[0], insMethods.size(), 898 &clsMethods[0], clsMethods.size(), AtEndLoc); 899 900 } else if (ObjCProtocolDecl *P = dyn_cast<ObjCProtocolDecl>(ClassDecl)) { 901 P->addMethods(&insMethods[0], insMethods.size(), 902 &clsMethods[0], clsMethods.size(), AtEndLoc); 903 } 904 else if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(ClassDecl)) { 905 C->addMethods(&insMethods[0], insMethods.size(), 906 &clsMethods[0], clsMethods.size(), AtEndLoc); 907 } 908 else if (ObjCImplementationDecl *IC = 909 dyn_cast<ObjCImplementationDecl>(ClassDecl)) { 910 IC->setLocEnd(AtEndLoc); 911 if (ObjCInterfaceDecl* IDecl = getObjCInterfaceDecl(IC->getIdentifier())) 912 ImplMethodsVsClassMethods(IC, IDecl); 913 } else { 914 ObjCCategoryImplDecl* CatImplClass = cast<ObjCCategoryImplDecl>(ClassDecl); 915 CatImplClass->setLocEnd(AtEndLoc); 916 ObjCInterfaceDecl* IDecl = CatImplClass->getClassInterface(); 917 // Find category interface decl and then check that all methods declared 918 // in this interface is implemented in the category @implementation. 919 if (IDecl) { 920 for (ObjCCategoryDecl *Categories = IDecl->getCategoryList(); 921 Categories; Categories = Categories->getNextClassCategory()) { 922 if (Categories->getIdentifier() == CatImplClass->getIdentifier()) { 923 ImplCategoryMethodsVsIntfMethods(CatImplClass, Categories); 924 break; 925 } 926 } 927 } 928 } 929} 930 931 932/// CvtQTToAstBitMask - utility routine to produce an AST bitmask for 933/// objective-c's type qualifier from the parser version of the same info. 934static Decl::ObjCDeclQualifier 935CvtQTToAstBitMask(ObjCDeclSpec::ObjCDeclQualifier PQTVal) { 936 Decl::ObjCDeclQualifier ret = Decl::OBJC_TQ_None; 937 if (PQTVal & ObjCDeclSpec::DQ_In) 938 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_In); 939 if (PQTVal & ObjCDeclSpec::DQ_Inout) 940 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Inout); 941 if (PQTVal & ObjCDeclSpec::DQ_Out) 942 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Out); 943 if (PQTVal & ObjCDeclSpec::DQ_Bycopy) 944 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Bycopy); 945 if (PQTVal & ObjCDeclSpec::DQ_Byref) 946 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Byref); 947 if (PQTVal & ObjCDeclSpec::DQ_Oneway) 948 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Oneway); 949 950 return ret; 951} 952 953Sema::DeclTy *Sema::ActOnMethodDeclaration( 954 SourceLocation MethodLoc, SourceLocation EndLoc, 955 tok::TokenKind MethodType, DeclTy *classDecl, 956 ObjCDeclSpec &ReturnQT, TypeTy *ReturnType, 957 Selector Sel, 958 // optional arguments. The number of types/arguments is obtained 959 // from the Sel.getNumArgs(). 960 ObjCDeclSpec *ArgQT, TypeTy **ArgTypes, IdentifierInfo **ArgNames, 961 AttributeList *AttrList, tok::ObjCKeywordKind MethodDeclKind, 962 bool isVariadic) { 963 Decl *ClassDecl = static_cast<Decl*>(classDecl); 964 965 // Make sure we can establish a context for the method. 966 if (!ClassDecl) { 967 Diag(MethodLoc, diag::error_missing_method_context); 968 return 0; 969 } 970 QualType resultDeclType; 971 972 if (ReturnType) 973 resultDeclType = QualType::getFromOpaquePtr(ReturnType); 974 else // get the type for "id". 975 resultDeclType = Context.getObjCIdType(); 976 977 ObjCMethodDecl* ObjCMethod = 978 ObjCMethodDecl::Create(Context, MethodLoc, EndLoc, Sel, resultDeclType, 979 ClassDecl, AttrList, 980 MethodType == tok::minus, isVariadic, 981 false, 982 MethodDeclKind == tok::objc_optional ? 983 ObjCMethodDecl::Optional : 984 ObjCMethodDecl::Required); 985 986 llvm::SmallVector<ParmVarDecl*, 16> Params; 987 988 for (unsigned i = 0; i < Sel.getNumArgs(); i++) { 989 // FIXME: arg->AttrList must be stored too! 990 QualType argType; 991 992 if (ArgTypes[i]) 993 argType = QualType::getFromOpaquePtr(ArgTypes[i]); 994 else 995 argType = Context.getObjCIdType(); 996 ParmVarDecl* Param = ParmVarDecl::Create(Context, ObjCMethod, 997 SourceLocation(/*FIXME*/), 998 ArgNames[i], argType, 999 VarDecl::None, 0, 0); 1000 Param->setObjCDeclQualifier( 1001 CvtQTToAstBitMask(ArgQT[i].getObjCDeclQualifier())); 1002 Params.push_back(Param); 1003 } 1004 1005 ObjCMethod->setMethodParams(&Params[0], Sel.getNumArgs()); 1006 ObjCMethod->setObjCDeclQualifier( 1007 CvtQTToAstBitMask(ReturnQT.getObjCDeclQualifier())); 1008 const ObjCMethodDecl *PrevMethod = 0; 1009 1010 // For implementations (which can be very "coarse grain"), we add the 1011 // method now. This allows the AST to implement lookup methods that work 1012 // incrementally (without waiting until we parse the @end). It also allows 1013 // us to flag multiple declaration errors as they occur. 1014 if (ObjCImplementationDecl *ImpDecl = 1015 dyn_cast<ObjCImplementationDecl>(ClassDecl)) { 1016 if (MethodType == tok::minus) { 1017 PrevMethod = ImpDecl->getInstanceMethod(Sel); 1018 ImpDecl->addInstanceMethod(ObjCMethod); 1019 } else { 1020 PrevMethod = ImpDecl->getClassMethod(Sel); 1021 ImpDecl->addClassMethod(ObjCMethod); 1022 } 1023 } 1024 else if (ObjCCategoryImplDecl *CatImpDecl = 1025 dyn_cast<ObjCCategoryImplDecl>(ClassDecl)) { 1026 if (MethodType == tok::minus) { 1027 PrevMethod = CatImpDecl->getInstanceMethod(Sel); 1028 CatImpDecl->addInstanceMethod(ObjCMethod); 1029 } else { 1030 PrevMethod = CatImpDecl->getClassMethod(Sel); 1031 CatImpDecl->addClassMethod(ObjCMethod); 1032 } 1033 } 1034 if (PrevMethod) { 1035 // You can never have two method definitions with the same name. 1036 Diag(ObjCMethod->getLocation(), diag::error_duplicate_method_decl, 1037 ObjCMethod->getSelector().getName()); 1038 Diag(PrevMethod->getLocation(), diag::err_previous_declaration); 1039 } 1040 return ObjCMethod; 1041} 1042 1043Sema::DeclTy *Sema::ActOnProperty(Scope *S, SourceLocation AtLoc, 1044 FieldDeclarator &FD, 1045 ObjCDeclSpec &ODS, 1046 Selector GetterSel, 1047 Selector SetterSel, 1048 tok::ObjCKeywordKind MethodImplKind) { 1049 QualType T = GetTypeForDeclarator(FD.D, S); 1050 ObjCPropertyDecl *PDecl = ObjCPropertyDecl::Create(Context, AtLoc, 1051 FD.D.getIdentifier(), T); 1052 // Regardless of setter/getter attribute, we save the default getter/setter 1053 // selector names in anticipation of declaration of setter/getter methods. 1054 PDecl->setGetterName(GetterSel); 1055 PDecl->setSetterName(SetterSel); 1056 1057 if (ODS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_readonly) 1058 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readonly); 1059 1060 if (ODS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_getter) 1061 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_getter); 1062 1063 if (ODS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_setter) 1064 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_setter); 1065 1066 if (ODS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_assign) 1067 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_assign); 1068 1069 if (ODS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_readwrite) 1070 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readwrite); 1071 1072 if (ODS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_retain) 1073 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_retain); 1074 1075 if (ODS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_copy) 1076 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_copy); 1077 1078 if (ODS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_nonatomic) 1079 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_nonatomic); 1080 1081 if (MethodImplKind == tok::objc_required) 1082 PDecl->setPropertyImplementation(ObjCPropertyDecl::Required); 1083 else if (MethodImplKind == tok::objc_optional) 1084 PDecl->setPropertyImplementation(ObjCPropertyDecl::Optional); 1085 1086 return PDecl; 1087} 1088 1089/// ActOnPropertyImplDecl - This routine performs semantic checks and 1090/// builds the AST node for a property implementation declaration; declared 1091/// as @synthesize or @dynamic. 1092/// 1093Sema::DeclTy *Sema::ActOnPropertyImplDecl(SourceLocation AtLoc, 1094 SourceLocation PropertyLoc, 1095 bool Synthesize, 1096 DeclTy *ClassCatImpDecl, 1097 IdentifierInfo *PropertyId, 1098 IdentifierInfo *PropertyIvar) { 1099 Decl *ClassImpDecl = static_cast<Decl*>(ClassCatImpDecl); 1100 // Make sure we have a context for the property implementation declaration. 1101 if (!ClassImpDecl) { 1102 Diag(AtLoc, diag::error_missing_property_context); 1103 return 0; 1104 } 1105 ObjCPropertyDecl *property = 0; 1106 ObjCInterfaceDecl* IDecl = 0; 1107 // Find the class or category class where this property must have 1108 // a declaration. 1109 ObjCImplementationDecl *IC = 0; 1110 ObjCCategoryImplDecl* CatImplClass = 0; 1111 if ((IC = dyn_cast<ObjCImplementationDecl>(ClassImpDecl))) { 1112 IDecl = getObjCInterfaceDecl(IC->getIdentifier()); 1113 // We always synthesize an interface for an implementation 1114 // without an interface decl. So, IDecl is always non-zero. 1115 assert(IDecl && 1116 "ActOnPropertyImplDecl - @implementation without @interface"); 1117 1118 // Look for this property declaration in the @implementation's @interface 1119 property = IDecl->FindPropertyDeclaration(PropertyId); 1120 if (!property) { 1121 Diag(PropertyLoc, diag::error_bad_property_decl, IDecl->getName()); 1122 return 0; 1123 } 1124 } 1125 else if ((CatImplClass = dyn_cast<ObjCCategoryImplDecl>(ClassImpDecl))) { 1126 if (Synthesize) { 1127 Diag(AtLoc, diag::error_synthesize_category_decl); 1128 return 0; 1129 } 1130 IDecl = CatImplClass->getClassInterface(); 1131 if (!IDecl) { 1132 Diag(AtLoc, diag::error_missing_property_interface); 1133 return 0; 1134 } 1135 ObjCCategoryDecl *Category = 1136 IDecl->FindCategoryDeclaration(CatImplClass->getIdentifier()); 1137 1138 // If category for this implementation not found, it is an error which 1139 // has already been reported eralier. 1140 if (!Category) 1141 return 0; 1142 // Look for this property declaration in @implementation's category 1143 property = Category->FindPropertyDeclaration(PropertyId); 1144 if (!property) { 1145 Diag(PropertyLoc, diag::error_bad_category_property_decl, 1146 Category->getName()); 1147 return 0; 1148 } 1149 } 1150 else { 1151 Diag(AtLoc, diag::error_bad_property_context); 1152 return 0; 1153 } 1154 ObjCIvarDecl *Ivar = 0; 1155 // Check that we have a valid, previously declared ivar for @synthesize 1156 if (Synthesize) { 1157 // @synthesize 1158 if (!PropertyIvar) 1159 PropertyIvar = PropertyId; 1160 // Check that this is a previously declared 'ivar' in 'IDecl' interface 1161 Ivar = IDecl->FindIvarDeclaration(PropertyIvar); 1162 if (!Ivar) { 1163 Diag(PropertyLoc, diag::error_missing_property_ivar_decl, 1164 PropertyId->getName()); 1165 return 0; 1166 } 1167 // Check that type of property and its ivar match. 1168 if (Ivar->getCanonicalType() != property->getCanonicalType()) { 1169 Diag(PropertyLoc, diag::error_property_ivar_type, property->getName(), 1170 Ivar->getName()); 1171 return 0; 1172 } 1173 1174 } else if (PropertyIvar) { 1175 // @dynamic 1176 Diag(PropertyLoc, diag::error_dynamic_property_ivar_decl); 1177 return 0; 1178 } 1179 assert (property && "ActOnPropertyImplDecl - property declaration missing"); 1180 ObjCPropertyImplDecl *PIDecl = 1181 ObjCPropertyImplDecl::Create(Context, AtLoc, PropertyLoc, property, 1182 (Synthesize ? 1183 ObjCPropertyImplDecl::OBJC_PR_IMPL_SYNTHSIZE 1184 : ObjCPropertyImplDecl::OBJC_PR_IMPL_DYNAMIC), 1185 Ivar); 1186 if (IC) 1187 IC->addPropertyImplementation(PIDecl); 1188 else 1189 CatImplClass->addPropertyImplementation(PIDecl); 1190 1191 return PIDecl; 1192} 1193