blob: f9da77ff2c54e73bad74ab29690a7dd2fa6974e1 [file] [log] [blame]
Chris Lattner855e51f2007-12-12 07:09:47 +00001//===--- SemaDeclObjC.cpp - Semantic Analysis for ObjC Declarations -------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner959e5be2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattner855e51f2007-12-12 07:09:47 +00007//
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
Ted Kremenek42730c52008-01-07 19:49:32 +000021/// ObjCActOnStartOfMethodDef - This routine sets up parameters; invisible
Chris Lattner855e51f2007-12-12 07:09:47 +000022/// and user declared, in the method definition's AST.
Ted Kremenek42730c52008-01-07 19:49:32 +000023void Sema::ObjCActOnStartOfMethodDef(Scope *FnBodyScope, DeclTy *D) {
Chris Lattner855e51f2007-12-12 07:09:47 +000024 assert(CurFunctionDecl == 0 && "Method parsing confused");
Ted Kremenek42730c52008-01-07 19:49:32 +000025 ObjCMethodDecl *MDecl = dyn_cast<ObjCMethodDecl>(static_cast<Decl *>(D));
Chris Lattner855e51f2007-12-12 07:09:47 +000026 assert(MDecl != 0 && "Not a method declarator!");
Steve Narofffe9eb6a2007-12-18 01:30:32 +000027
28 // Allow the rest of sema to find private method decl implementations.
29 if (MDecl->isInstance())
30 AddInstanceMethodToGlobalPool(MDecl);
31 else
32 AddFactoryMethodToGlobalPool(MDecl);
Chris Lattner855e51f2007-12-12 07:09:47 +000033
34 // Allow all of Sema to see that we are entering a method definition.
35 CurMethodDecl = 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 PI.InvalidType = false;
Nate Begeman9f3c4bb2008-02-17 21:20:31 +000045 PI.AttrList = 0;
Gabor Greif9b2e0f92008-02-29 20:35:55 +000046 PI.TypeInfo = Context.getObjCIdType().getAsOpaquePtr();
47
Chris Lattner855e51f2007-12-12 07:09:47 +000048 if (MDecl->isInstance()) {
Gabor Greif9b2e0f92008-02-29 20:35:55 +000049 if (ObjCInterfaceDecl *OID = MDecl->getClassInterface()) {
50 // There may be no interface context due to error in declaration of the
51 // interface (which has been reported). Recover gracefully
Fariborz Jahanian6833b3b2008-01-10 20:33:58 +000052 QualType selfTy = Context.getObjCInterfaceType(OID);
53 selfTy = Context.getPointerType(selfTy);
54 PI.TypeInfo = selfTy.getAsOpaquePtr();
55 }
Gabor Greif9b2e0f92008-02-29 20:35:55 +000056 }
57
Chris Lattner855e51f2007-12-12 07:09:47 +000058 CurMethodDecl->setSelfDecl(ActOnParamDeclarator(PI, FnBodyScope));
59
60 PI.Ident = &Context.Idents.get("_cmd");
Ted Kremenek42730c52008-01-07 19:49:32 +000061 PI.TypeInfo = Context.getObjCSelType().getAsOpaquePtr();
Chris Lattner855e51f2007-12-12 07:09:47 +000062 ActOnParamDeclarator(PI, FnBodyScope);
63
Chris Lattner685d7922008-03-16 01:07:14 +000064 for (unsigned i = 0, e = MDecl->getNumParams(); i != e; ++i) {
Chris Lattner855e51f2007-12-12 07:09:47 +000065 ParmVarDecl *PDecl = MDecl->getParamDecl(i);
66 PI.Ident = PDecl->getIdentifier();
67 PI.IdentLoc = PDecl->getLocation(); // user vars have a real location.
68 PI.TypeInfo = PDecl->getType().getAsOpaquePtr();
Fariborz Jahanian00a313b2008-01-21 22:59:53 +000069 MDecl->setParamDecl(i, ActOnParamDeclarator(PI, FnBodyScope));
Chris Lattner855e51f2007-12-12 07:09:47 +000070 }
71}
72
73Sema::DeclTy *Sema::ActOnStartClassInterface(
74 SourceLocation AtInterfaceLoc,
75 IdentifierInfo *ClassName, SourceLocation ClassLoc,
76 IdentifierInfo *SuperName, SourceLocation SuperLoc,
77 IdentifierInfo **ProtocolNames, unsigned NumProtocols,
78 SourceLocation EndProtoLoc, AttributeList *AttrList) {
79 assert(ClassName && "Missing class identifier");
80
81 // Check for another declaration kind with the same name.
82 ScopedDecl *PrevDecl = LookupInterfaceDecl(ClassName);
Ted Kremenek42730c52008-01-07 19:49:32 +000083 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
Chris Lattner855e51f2007-12-12 07:09:47 +000084 Diag(ClassLoc, diag::err_redefinition_different_kind,
85 ClassName->getName());
86 Diag(PrevDecl->getLocation(), diag::err_previous_definition);
87 }
88
Ted Kremenek42730c52008-01-07 19:49:32 +000089 ObjCInterfaceDecl* IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
Chris Lattner855e51f2007-12-12 07:09:47 +000090 if (IDecl) {
91 // Class already seen. Is it a forward declaration?
92 if (!IDecl->isForwardDecl())
93 Diag(AtInterfaceLoc, diag::err_duplicate_class_def, IDecl->getName());
94 else {
95 IDecl->setLocation(AtInterfaceLoc);
96 IDecl->setForwardDecl(false);
97 IDecl->AllocIntfRefProtocols(NumProtocols);
98 }
99 }
100 else {
Chris Lattner0db541b2008-03-16 01:15:50 +0000101 IDecl = ObjCInterfaceDecl::Create(Context, AtInterfaceLoc, NumProtocols,
102 ClassName);
Chris Lattner855e51f2007-12-12 07:09:47 +0000103
104 // Chain & install the interface decl into the identifier.
105 IDecl->setNext(ClassName->getFETokenInfo<ScopedDecl>());
106 ClassName->setFETokenInfo(IDecl);
107
108 // Remember that this needs to be removed when the scope is popped.
109 TUScope->AddDecl(IDecl);
110 }
111
112 if (SuperName) {
Ted Kremenek42730c52008-01-07 19:49:32 +0000113 ObjCInterfaceDecl* SuperClassEntry = 0;
Chris Lattner855e51f2007-12-12 07:09:47 +0000114 // Check if a different kind of symbol declared in this scope.
115 PrevDecl = LookupInterfaceDecl(SuperName);
Ted Kremenek42730c52008-01-07 19:49:32 +0000116 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
Chris Lattner855e51f2007-12-12 07:09:47 +0000117 Diag(SuperLoc, diag::err_redefinition_different_kind,
118 SuperName->getName());
119 Diag(PrevDecl->getLocation(), diag::err_previous_definition);
120 }
121 else {
122 // Check that super class is previously defined
Ted Kremenek42730c52008-01-07 19:49:32 +0000123 SuperClassEntry = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
Chris Lattner855e51f2007-12-12 07:09:47 +0000124
125 if (!SuperClassEntry || SuperClassEntry->isForwardDecl()) {
126 Diag(AtInterfaceLoc, diag::err_undef_superclass,
127 SuperClassEntry ? SuperClassEntry->getName()
128 : SuperName->getName(),
129 ClassName->getName());
130 }
131 }
132 IDecl->setSuperClass(SuperClassEntry);
133 IDecl->setLocEnd(SuperLoc);
134 } else { // we have a root class.
135 IDecl->setLocEnd(ClassLoc);
136 }
137
138 /// Check then save referenced protocols
139 if (NumProtocols) {
140 for (unsigned int i = 0; i != NumProtocols; i++) {
Ted Kremenek42730c52008-01-07 19:49:32 +0000141 ObjCProtocolDecl* RefPDecl = ObjCProtocols[ProtocolNames[i]];
Chris Lattner855e51f2007-12-12 07:09:47 +0000142 if (!RefPDecl || RefPDecl->isForwardDecl())
143 Diag(ClassLoc, diag::warn_undef_protocolref,
144 ProtocolNames[i]->getName(),
145 ClassName->getName());
Fariborz Jahanian87829072007-12-20 19:24:10 +0000146 IDecl->setIntfRefProtocols(i, RefPDecl);
Chris Lattner855e51f2007-12-12 07:09:47 +0000147 }
148 IDecl->setLocEnd(EndProtoLoc);
149 }
150 return IDecl;
151}
152
153/// ActOnCompatiblityAlias - this action is called after complete parsing of
154/// @compaatibility_alias declaration. It sets up the alias relationships.
155Sema::DeclTy *Sema::ActOnCompatiblityAlias(
156 SourceLocation AtCompatibilityAliasLoc,
157 IdentifierInfo *AliasName, SourceLocation AliasLocation,
158 IdentifierInfo *ClassName, SourceLocation ClassLocation) {
159 // Look for previous declaration of alias name
160 ScopedDecl *ADecl = LookupScopedDecl(AliasName, Decl::IDNS_Ordinary,
161 AliasLocation, TUScope);
162 if (ADecl) {
Ted Kremenek42730c52008-01-07 19:49:32 +0000163 if (isa<ObjCCompatibleAliasDecl>(ADecl)) {
Chris Lattner855e51f2007-12-12 07:09:47 +0000164 Diag(AliasLocation, diag::warn_previous_alias_decl);
165 Diag(ADecl->getLocation(), diag::warn_previous_declaration);
166 }
167 else {
168 Diag(AliasLocation, diag::err_conflicting_aliasing_type,
169 AliasName->getName());
170 Diag(ADecl->getLocation(), diag::err_previous_declaration);
171 }
172 return 0;
173 }
174 // Check for class declaration
175 ScopedDecl *CDecl = LookupScopedDecl(ClassName, Decl::IDNS_Ordinary,
176 ClassLocation, TUScope);
Ted Kremenek42730c52008-01-07 19:49:32 +0000177 if (!CDecl || !isa<ObjCInterfaceDecl>(CDecl)) {
Chris Lattner855e51f2007-12-12 07:09:47 +0000178 Diag(ClassLocation, diag::warn_undef_interface,
179 ClassName->getName());
180 if (CDecl)
181 Diag(CDecl->getLocation(), diag::warn_previous_declaration);
182 return 0;
183 }
184 // Everything checked out, instantiate a new alias declaration ast
Ted Kremenek42730c52008-01-07 19:49:32 +0000185 ObjCCompatibleAliasDecl *AliasDecl =
186 new ObjCCompatibleAliasDecl(AtCompatibilityAliasLoc,
Chris Lattner855e51f2007-12-12 07:09:47 +0000187 AliasName,
Ted Kremenek42730c52008-01-07 19:49:32 +0000188 dyn_cast<ObjCInterfaceDecl>(CDecl));
Chris Lattner855e51f2007-12-12 07:09:47 +0000189
190 // Chain & install the interface decl into the identifier.
191 AliasDecl->setNext(AliasName->getFETokenInfo<ScopedDecl>());
192 AliasName->setFETokenInfo(AliasDecl);
193 return AliasDecl;
194}
195
196Sema::DeclTy *Sema::ActOnStartProtocolInterface(
197 SourceLocation AtProtoInterfaceLoc,
198 IdentifierInfo *ProtocolName, SourceLocation ProtocolLoc,
199 IdentifierInfo **ProtoRefNames, unsigned NumProtoRefs,
200 SourceLocation EndProtoLoc) {
201 assert(ProtocolName && "Missing protocol identifier");
Ted Kremenek42730c52008-01-07 19:49:32 +0000202 ObjCProtocolDecl *PDecl = ObjCProtocols[ProtocolName];
Chris Lattner855e51f2007-12-12 07:09:47 +0000203 if (PDecl) {
204 // Protocol already seen. Better be a forward protocol declaration
Chris Lattnerc1881852008-03-16 01:25:17 +0000205 if (!PDecl->isForwardDecl()) {
Chris Lattner855e51f2007-12-12 07:09:47 +0000206 Diag(ProtocolLoc, diag::err_duplicate_protocol_def,
207 ProtocolName->getName());
Chris Lattnerc1881852008-03-16 01:25:17 +0000208 // Just return the protocol we already had.
209 // FIXME: don't leak the objects passed in!
210 return PDecl;
Chris Lattner855e51f2007-12-12 07:09:47 +0000211 }
Chris Lattnerc1881852008-03-16 01:25:17 +0000212
213 PDecl->setForwardDecl(false);
214 PDecl->AllocReferencedProtocols(NumProtoRefs);
215 } else {
Chris Lattner180f7e22008-03-16 01:23:04 +0000216 PDecl = ObjCProtocolDecl::Create(Context, AtProtoInterfaceLoc, NumProtoRefs,
Chris Lattner7afba9c2008-03-16 20:19:15 +0000217 ProtocolName);
218 PDecl->setForwardDecl(false);
Ted Kremenek42730c52008-01-07 19:49:32 +0000219 ObjCProtocols[ProtocolName] = PDecl;
Chris Lattner180f7e22008-03-16 01:23:04 +0000220 }
Chris Lattner855e51f2007-12-12 07:09:47 +0000221
222 if (NumProtoRefs) {
Chris Lattner7afba9c2008-03-16 20:19:15 +0000223 /// Check then save referenced protocols.
Chris Lattner855e51f2007-12-12 07:09:47 +0000224 for (unsigned int i = 0; i != NumProtoRefs; i++) {
Ted Kremenek42730c52008-01-07 19:49:32 +0000225 ObjCProtocolDecl* RefPDecl = ObjCProtocols[ProtoRefNames[i]];
Chris Lattner855e51f2007-12-12 07:09:47 +0000226 if (!RefPDecl || RefPDecl->isForwardDecl())
227 Diag(ProtocolLoc, diag::warn_undef_protocolref,
228 ProtoRefNames[i]->getName(),
229 ProtocolName->getName());
Fariborz Jahanian87829072007-12-20 19:24:10 +0000230 PDecl->setReferencedProtocols(i, RefPDecl);
Chris Lattner855e51f2007-12-12 07:09:47 +0000231 }
232 PDecl->setLocEnd(EndProtoLoc);
233 }
234 return PDecl;
235}
236
237/// FindProtocolDeclaration - This routine looks up protocols and
238/// issuer error if they are not declared. It returns list of protocol
239/// declarations in its 'Protocols' argument.
240void
241Sema::FindProtocolDeclaration(SourceLocation TypeLoc,
242 IdentifierInfo **ProtocolId,
243 unsigned NumProtocols,
244 llvm::SmallVector<DeclTy *,8> &Protocols) {
245 for (unsigned i = 0; i != NumProtocols; ++i) {
Ted Kremenek42730c52008-01-07 19:49:32 +0000246 ObjCProtocolDecl *PDecl = ObjCProtocols[ProtocolId[i]];
Chris Lattner855e51f2007-12-12 07:09:47 +0000247 if (!PDecl)
248 Diag(TypeLoc, diag::err_undeclared_protocol,
249 ProtocolId[i]->getName());
250 else
251 Protocols.push_back(PDecl);
252 }
253}
254
255/// ActOnForwardProtocolDeclaration -
256Action::DeclTy *
257Sema::ActOnForwardProtocolDeclaration(SourceLocation AtProtocolLoc,
258 IdentifierInfo **IdentList, unsigned NumElts) {
Ted Kremenek42730c52008-01-07 19:49:32 +0000259 llvm::SmallVector<ObjCProtocolDecl*, 32> Protocols;
Chris Lattner855e51f2007-12-12 07:09:47 +0000260
261 for (unsigned i = 0; i != NumElts; ++i) {
Chris Lattner7afba9c2008-03-16 20:19:15 +0000262 IdentifierInfo *Ident = IdentList[i];
263 ObjCProtocolDecl *&PDecl = ObjCProtocols[Ident];
264 if (PDecl == 0) { // Not already seen?
Chris Lattner855e51f2007-12-12 07:09:47 +0000265 // FIXME: Pass in the location of the identifier!
Chris Lattner7afba9c2008-03-16 20:19:15 +0000266 PDecl = ObjCProtocolDecl::Create(Context, AtProtocolLoc, 0, Ident);
Chris Lattner855e51f2007-12-12 07:09:47 +0000267 }
268
269 Protocols.push_back(PDecl);
270 }
Chris Lattnere29dc832008-03-16 20:34:23 +0000271 return ObjCForwardProtocolDecl::Create(Context, AtProtocolLoc,
272 &Protocols[0], Protocols.size());
Chris Lattner855e51f2007-12-12 07:09:47 +0000273}
274
275Sema::DeclTy *Sema::ActOnStartCategoryInterface(
276 SourceLocation AtInterfaceLoc,
277 IdentifierInfo *ClassName, SourceLocation ClassLoc,
278 IdentifierInfo *CategoryName, SourceLocation CategoryLoc,
279 IdentifierInfo **ProtoRefNames, unsigned NumProtoRefs,
280 SourceLocation EndProtoLoc) {
Ted Kremenek42730c52008-01-07 19:49:32 +0000281 ObjCInterfaceDecl *IDecl = getObjCInterfaceDecl(ClassName);
Chris Lattner855e51f2007-12-12 07:09:47 +0000282
Chris Lattnere29dc832008-03-16 20:34:23 +0000283 ObjCCategoryDecl *CDecl =
Chris Lattner321b5d12008-03-16 20:47:45 +0000284 ObjCCategoryDecl::Create(Context, AtInterfaceLoc, CategoryName);
Chris Lattner855e51f2007-12-12 07:09:47 +0000285 CDecl->setClassInterface(IDecl);
Fariborz Jahanian6669a582008-01-17 20:33:24 +0000286
287 /// Check that class of this category is already completely declared.
288 if (!IDecl || IDecl->isForwardDecl())
289 Diag(ClassLoc, diag::err_undef_interface, ClassName->getName());
290 else {
291 /// Check for duplicate interface declaration for this category
292 ObjCCategoryDecl *CDeclChain;
293 for (CDeclChain = IDecl->getCategoryList(); CDeclChain;
294 CDeclChain = CDeclChain->getNextClassCategory()) {
295 if (CDeclChain->getIdentifier() == CategoryName) {
296 Diag(CategoryLoc, diag::err_dup_category_def, ClassName->getName(),
297 CategoryName->getName());
298 break;
299 }
Chris Lattner855e51f2007-12-12 07:09:47 +0000300 }
Chris Lattner855e51f2007-12-12 07:09:47 +0000301 if (!CDeclChain)
302 CDecl->insertNextClassCategory();
Fariborz Jahanian6669a582008-01-17 20:33:24 +0000303 }
Chris Lattner855e51f2007-12-12 07:09:47 +0000304
305 if (NumProtoRefs) {
Chris Lattner321b5d12008-03-16 20:47:45 +0000306 llvm::SmallVector<ObjCProtocolDecl*, 32> RefProtocols;
307 /// Check and then save the referenced protocols.
Chris Lattner855e51f2007-12-12 07:09:47 +0000308 for (unsigned int i = 0; i != NumProtoRefs; i++) {
Ted Kremenek42730c52008-01-07 19:49:32 +0000309 ObjCProtocolDecl* RefPDecl = ObjCProtocols[ProtoRefNames[i]];
Chris Lattner855e51f2007-12-12 07:09:47 +0000310 if (!RefPDecl || RefPDecl->isForwardDecl()) {
311 Diag(CategoryLoc, diag::warn_undef_protocolref,
312 ProtoRefNames[i]->getName(),
313 CategoryName->getName());
314 }
Chris Lattner321b5d12008-03-16 20:47:45 +0000315 if (RefPDecl)
316 RefProtocols.push_back(RefPDecl);
Chris Lattner855e51f2007-12-12 07:09:47 +0000317 }
Chris Lattner321b5d12008-03-16 20:47:45 +0000318 if (!RefProtocols.empty())
319 CDecl->setReferencedProtocolList(&RefProtocols[0], RefProtocols.size());
Chris Lattner855e51f2007-12-12 07:09:47 +0000320 }
Chris Lattner321b5d12008-03-16 20:47:45 +0000321 CDecl->setLocEnd(EndProtoLoc);
Chris Lattner855e51f2007-12-12 07:09:47 +0000322 return CDecl;
323}
324
325/// ActOnStartCategoryImplementation - Perform semantic checks on the
Ted Kremenek42730c52008-01-07 19:49:32 +0000326/// category implementation declaration and build an ObjCCategoryImplDecl
Chris Lattner855e51f2007-12-12 07:09:47 +0000327/// object.
328Sema::DeclTy *Sema::ActOnStartCategoryImplementation(
329 SourceLocation AtCatImplLoc,
330 IdentifierInfo *ClassName, SourceLocation ClassLoc,
331 IdentifierInfo *CatName, SourceLocation CatLoc) {
Ted Kremenek42730c52008-01-07 19:49:32 +0000332 ObjCInterfaceDecl *IDecl = getObjCInterfaceDecl(ClassName);
Chris Lattner1b6de332008-03-16 20:53:07 +0000333 ObjCCategoryImplDecl *CDecl =
334 ObjCCategoryImplDecl::Create(Context, AtCatImplLoc, CatName, IDecl);
Chris Lattner855e51f2007-12-12 07:09:47 +0000335 /// Check that class of this category is already completely declared.
336 if (!IDecl || IDecl->isForwardDecl())
337 Diag(ClassLoc, diag::err_undef_interface, ClassName->getName());
338
339 /// TODO: Check that CatName, category name, is not used in another
340 // implementation.
341 return CDecl;
342}
343
344Sema::DeclTy *Sema::ActOnStartClassImplementation(
345 SourceLocation AtClassImplLoc,
346 IdentifierInfo *ClassName, SourceLocation ClassLoc,
347 IdentifierInfo *SuperClassname,
348 SourceLocation SuperClassLoc) {
Ted Kremenek42730c52008-01-07 19:49:32 +0000349 ObjCInterfaceDecl* IDecl = 0;
Chris Lattner855e51f2007-12-12 07:09:47 +0000350 // Check for another declaration kind with the same name.
351 ScopedDecl *PrevDecl = LookupInterfaceDecl(ClassName);
Ted Kremenek42730c52008-01-07 19:49:32 +0000352 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
Chris Lattner855e51f2007-12-12 07:09:47 +0000353 Diag(ClassLoc, diag::err_redefinition_different_kind,
354 ClassName->getName());
355 Diag(PrevDecl->getLocation(), diag::err_previous_definition);
356 }
357 else {
358 // Is there an interface declaration of this class; if not, warn!
Ted Kremenek42730c52008-01-07 19:49:32 +0000359 IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
Chris Lattner855e51f2007-12-12 07:09:47 +0000360 if (!IDecl)
361 Diag(ClassLoc, diag::warn_undef_interface, ClassName->getName());
362 }
363
364 // Check that super class name is valid class name
Ted Kremenek42730c52008-01-07 19:49:32 +0000365 ObjCInterfaceDecl* SDecl = 0;
Chris Lattner855e51f2007-12-12 07:09:47 +0000366 if (SuperClassname) {
367 // Check if a different kind of symbol declared in this scope.
368 PrevDecl = LookupInterfaceDecl(SuperClassname);
Ted Kremenek42730c52008-01-07 19:49:32 +0000369 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
Chris Lattner855e51f2007-12-12 07:09:47 +0000370 Diag(SuperClassLoc, diag::err_redefinition_different_kind,
371 SuperClassname->getName());
372 Diag(PrevDecl->getLocation(), diag::err_previous_definition);
373 }
374 else {
Ted Kremenek42730c52008-01-07 19:49:32 +0000375 SDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
Chris Lattner855e51f2007-12-12 07:09:47 +0000376 if (!SDecl)
377 Diag(SuperClassLoc, diag::err_undef_superclass,
378 SuperClassname->getName(), ClassName->getName());
379 else if (IDecl && IDecl->getSuperClass() != SDecl) {
380 // This implementation and its interface do not have the same
381 // super class.
382 Diag(SuperClassLoc, diag::err_conflicting_super_class,
383 SDecl->getName());
384 Diag(SDecl->getLocation(), diag::err_previous_definition);
385 }
386 }
387 }
388
389 if (!IDecl) {
390 // Legacy case of @implementation with no corresponding @interface.
391 // Build, chain & install the interface decl into the identifier.
Chris Lattner0db541b2008-03-16 01:15:50 +0000392 IDecl = ObjCInterfaceDecl::Create(Context, AtClassImplLoc, 0, ClassName,
393 false, true);
Chris Lattner855e51f2007-12-12 07:09:47 +0000394 IDecl->setNext(ClassName->getFETokenInfo<ScopedDecl>());
395 ClassName->setFETokenInfo(IDecl);
396 IDecl->setSuperClass(SDecl);
397 IDecl->setLocEnd(ClassLoc);
398
399 // Remember that this needs to be removed when the scope is popped.
400 TUScope->AddDecl(IDecl);
401 }
402
Ted Kremenek42730c52008-01-07 19:49:32 +0000403 ObjCImplementationDecl* IMPDecl =
Chris Lattner1b6de332008-03-16 20:53:07 +0000404 ObjCImplementationDecl::Create(Context, AtClassImplLoc, ClassName,
405 IDecl, SDecl);
Chris Lattner855e51f2007-12-12 07:09:47 +0000406
407 // Check that there is no duplicate implementation of this class.
Ted Kremenek42730c52008-01-07 19:49:32 +0000408 if (ObjCImplementations[ClassName])
Chris Lattner1b6de332008-03-16 20:53:07 +0000409 // FIXME: Don't leak everything!
Chris Lattner855e51f2007-12-12 07:09:47 +0000410 Diag(ClassLoc, diag::err_dup_implementation_class, ClassName->getName());
411 else // add it to the list.
Ted Kremenek42730c52008-01-07 19:49:32 +0000412 ObjCImplementations[ClassName] = IMPDecl;
Chris Lattner855e51f2007-12-12 07:09:47 +0000413 return IMPDecl;
414}
415
Ted Kremenek42730c52008-01-07 19:49:32 +0000416void Sema::CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
417 ObjCIvarDecl **ivars, unsigned numIvars,
Chris Lattner855e51f2007-12-12 07:09:47 +0000418 SourceLocation RBrace) {
419 assert(ImpDecl && "missing implementation decl");
Ted Kremenek42730c52008-01-07 19:49:32 +0000420 ObjCInterfaceDecl* IDecl = getObjCInterfaceDecl(ImpDecl->getIdentifier());
Chris Lattner855e51f2007-12-12 07:09:47 +0000421 if (!IDecl)
422 return;
423 /// Check case of non-existing @interface decl.
424 /// (legacy objective-c @implementation decl without an @interface decl).
425 /// Add implementations's ivar to the synthesize class's ivar list.
426 if (IDecl->ImplicitInterfaceDecl()) {
427 IDecl->addInstanceVariablesToClass(ivars, numIvars, RBrace);
428 return;
429 }
430 // If implementation has empty ivar list, just return.
431 if (numIvars == 0)
432 return;
433
434 assert(ivars && "missing @implementation ivars");
435
436 // Check interface's Ivar list against those in the implementation.
437 // names and types must match.
438 //
Chris Lattner855e51f2007-12-12 07:09:47 +0000439 unsigned j = 0;
Ted Kremenek42730c52008-01-07 19:49:32 +0000440 ObjCInterfaceDecl::ivar_iterator
Chris Lattner9d76c722007-12-12 17:58:05 +0000441 IVI = IDecl->ivar_begin(), IVE = IDecl->ivar_end();
442 for (; numIvars > 0 && IVI != IVE; ++IVI) {
Ted Kremenek42730c52008-01-07 19:49:32 +0000443 ObjCIvarDecl* ImplIvar = ivars[j++];
444 ObjCIvarDecl* ClsIvar = *IVI;
Chris Lattner855e51f2007-12-12 07:09:47 +0000445 assert (ImplIvar && "missing implementation ivar");
446 assert (ClsIvar && "missing class ivar");
447 if (ImplIvar->getCanonicalType() != ClsIvar->getCanonicalType()) {
448 Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_type,
449 ImplIvar->getIdentifier()->getName());
450 Diag(ClsIvar->getLocation(), diag::err_previous_definition,
451 ClsIvar->getIdentifier()->getName());
452 }
453 // TODO: Two mismatched (unequal width) Ivar bitfields should be diagnosed
454 // as error.
455 else if (ImplIvar->getIdentifier() != ClsIvar->getIdentifier()) {
456 Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_name,
457 ImplIvar->getIdentifier()->getName());
458 Diag(ClsIvar->getLocation(), diag::err_previous_definition,
459 ClsIvar->getIdentifier()->getName());
Chris Lattner1cc669d2007-12-12 18:11:49 +0000460 return;
Chris Lattner855e51f2007-12-12 07:09:47 +0000461 }
462 --numIvars;
Chris Lattner855e51f2007-12-12 07:09:47 +0000463 }
Chris Lattner1cc669d2007-12-12 18:11:49 +0000464
465 if (numIvars > 0)
Chris Lattner847de6f2007-12-12 18:19:52 +0000466 Diag(ivars[j]->getLocation(), diag::err_inconsistant_ivar_count);
Chris Lattner1cc669d2007-12-12 18:11:49 +0000467 else if (IVI != IVE)
Chris Lattner847de6f2007-12-12 18:19:52 +0000468 Diag((*IVI)->getLocation(), diag::err_inconsistant_ivar_count);
Chris Lattner855e51f2007-12-12 07:09:47 +0000469}
470
Steve Naroffb4f48512008-02-10 21:38:56 +0000471void Sema::WarnUndefinedMethod(SourceLocation ImpLoc, ObjCMethodDecl *method,
472 bool &IncompleteImpl) {
473 if (!IncompleteImpl) {
474 Diag(ImpLoc, diag::warn_incomplete_impl);
475 IncompleteImpl = true;
476 }
477 Diag(ImpLoc, diag::warn_undef_method_impl, method->getSelector().getName());
478}
479
Steve Naroffb268d2a2008-02-08 22:06:17 +0000480/// CheckProtocolMethodDefs - This routine checks unimplemented methods
Chris Lattner855e51f2007-12-12 07:09:47 +0000481/// Declared in protocol, and those referenced by it.
Steve Naroffb268d2a2008-02-08 22:06:17 +0000482void Sema::CheckProtocolMethodDefs(SourceLocation ImpLoc,
483 ObjCProtocolDecl *PDecl,
Chris Lattner855e51f2007-12-12 07:09:47 +0000484 bool& IncompleteImpl,
Steve Naroffb268d2a2008-02-08 22:06:17 +0000485 const llvm::DenseSet<Selector> &InsMap,
486 const llvm::DenseSet<Selector> &ClsMap) {
Chris Lattner855e51f2007-12-12 07:09:47 +0000487 // check unimplemented instance methods.
Ted Kremenek42730c52008-01-07 19:49:32 +0000488 for (ObjCProtocolDecl::instmeth_iterator I = PDecl->instmeth_begin(),
Steve Naroff2ce399a2007-12-14 23:37:57 +0000489 E = PDecl->instmeth_end(); I != E; ++I) {
Ted Kremenek42730c52008-01-07 19:49:32 +0000490 ObjCMethodDecl *method = *I;
Steve Naroff2ce399a2007-12-14 23:37:57 +0000491 if (!InsMap.count(method->getSelector()) &&
Steve Naroffb4f48512008-02-10 21:38:56 +0000492 method->getImplementationControl() != ObjCMethodDecl::Optional)
493 WarnUndefinedMethod(ImpLoc, method, IncompleteImpl);
Chris Lattner855e51f2007-12-12 07:09:47 +0000494 }
495 // check unimplemented class methods
Ted Kremenek42730c52008-01-07 19:49:32 +0000496 for (ObjCProtocolDecl::classmeth_iterator I = PDecl->classmeth_begin(),
Steve Naroff2ce399a2007-12-14 23:37:57 +0000497 E = PDecl->classmeth_end(); I != E; ++I) {
Ted Kremenek42730c52008-01-07 19:49:32 +0000498 ObjCMethodDecl *method = *I;
Steve Naroff2ce399a2007-12-14 23:37:57 +0000499 if (!ClsMap.count(method->getSelector()) &&
Steve Naroffb4f48512008-02-10 21:38:56 +0000500 method->getImplementationControl() != ObjCMethodDecl::Optional)
501 WarnUndefinedMethod(ImpLoc, method, IncompleteImpl);
Steve Naroff2ce399a2007-12-14 23:37:57 +0000502 }
Chris Lattner855e51f2007-12-12 07:09:47 +0000503 // Check on this protocols's referenced protocols, recursively
Ted Kremenek42730c52008-01-07 19:49:32 +0000504 ObjCProtocolDecl** RefPDecl = PDecl->getReferencedProtocols();
Fariborz Jahanian87829072007-12-20 19:24:10 +0000505 for (unsigned i = 0; i < PDecl->getNumReferencedProtocols(); i++)
Steve Naroffb268d2a2008-02-08 22:06:17 +0000506 CheckProtocolMethodDefs(ImpLoc, RefPDecl[i], IncompleteImpl, InsMap, ClsMap);
Chris Lattner855e51f2007-12-12 07:09:47 +0000507}
508
Ted Kremenek42730c52008-01-07 19:49:32 +0000509void Sema::ImplMethodsVsClassMethods(ObjCImplementationDecl* IMPDecl,
510 ObjCInterfaceDecl* IDecl) {
Chris Lattner855e51f2007-12-12 07:09:47 +0000511 llvm::DenseSet<Selector> InsMap;
512 // Check and see if instance methods in class interface have been
513 // implemented in the implementation class.
Ted Kremenek42730c52008-01-07 19:49:32 +0000514 for (ObjCImplementationDecl::instmeth_iterator I = IMPDecl->instmeth_begin(),
Chris Lattner9d76c722007-12-12 17:58:05 +0000515 E = IMPDecl->instmeth_end(); I != E; ++I)
516 InsMap.insert((*I)->getSelector());
Chris Lattner855e51f2007-12-12 07:09:47 +0000517
518 bool IncompleteImpl = false;
Ted Kremenek42730c52008-01-07 19:49:32 +0000519 for (ObjCInterfaceDecl::instmeth_iterator I = IDecl->instmeth_begin(),
Chris Lattner9d76c722007-12-12 17:58:05 +0000520 E = IDecl->instmeth_end(); I != E; ++I)
Steve Naroffb4f48512008-02-10 21:38:56 +0000521 if (!InsMap.count((*I)->getSelector()))
522 WarnUndefinedMethod(IMPDecl->getLocation(), *I, IncompleteImpl);
Chris Lattner9d76c722007-12-12 17:58:05 +0000523
Chris Lattner855e51f2007-12-12 07:09:47 +0000524 llvm::DenseSet<Selector> ClsMap;
525 // Check and see if class methods in class interface have been
526 // implemented in the implementation class.
Ted Kremenek42730c52008-01-07 19:49:32 +0000527 for (ObjCImplementationDecl::classmeth_iterator I =IMPDecl->classmeth_begin(),
Chris Lattner9d76c722007-12-12 17:58:05 +0000528 E = IMPDecl->classmeth_end(); I != E; ++I)
529 ClsMap.insert((*I)->getSelector());
Chris Lattner855e51f2007-12-12 07:09:47 +0000530
Ted Kremenek42730c52008-01-07 19:49:32 +0000531 for (ObjCInterfaceDecl::classmeth_iterator I = IDecl->classmeth_begin(),
Chris Lattner9d76c722007-12-12 17:58:05 +0000532 E = IDecl->classmeth_end(); I != E; ++I)
Steve Naroffb4f48512008-02-10 21:38:56 +0000533 if (!ClsMap.count((*I)->getSelector()))
534 WarnUndefinedMethod(IMPDecl->getLocation(), *I, IncompleteImpl);
Chris Lattner855e51f2007-12-12 07:09:47 +0000535
536 // Check the protocol list for unimplemented methods in the @implementation
537 // class.
Ted Kremenek42730c52008-01-07 19:49:32 +0000538 ObjCProtocolDecl** protocols = IDecl->getReferencedProtocols();
Fariborz Jahanian87829072007-12-20 19:24:10 +0000539 for (unsigned i = 0; i < IDecl->getNumIntfRefProtocols(); i++)
Steve Naroffb268d2a2008-02-08 22:06:17 +0000540 CheckProtocolMethodDefs(IMPDecl->getLocation(), protocols[i],
541 IncompleteImpl, InsMap, ClsMap);
Chris Lattner855e51f2007-12-12 07:09:47 +0000542}
543
544/// ImplCategoryMethodsVsIntfMethods - Checks that methods declared in the
545/// category interface is implemented in the category @implementation.
Ted Kremenek42730c52008-01-07 19:49:32 +0000546void Sema::ImplCategoryMethodsVsIntfMethods(ObjCCategoryImplDecl *CatImplDecl,
547 ObjCCategoryDecl *CatClassDecl) {
Chris Lattner855e51f2007-12-12 07:09:47 +0000548 llvm::DenseSet<Selector> InsMap;
549 // Check and see if instance methods in category interface have been
550 // implemented in its implementation class.
Ted Kremenek42730c52008-01-07 19:49:32 +0000551 for (ObjCCategoryImplDecl::instmeth_iterator I =CatImplDecl->instmeth_begin(),
Chris Lattner9d76c722007-12-12 17:58:05 +0000552 E = CatImplDecl->instmeth_end(); I != E; ++I)
553 InsMap.insert((*I)->getSelector());
Chris Lattner855e51f2007-12-12 07:09:47 +0000554
555 bool IncompleteImpl = false;
Ted Kremenek42730c52008-01-07 19:49:32 +0000556 for (ObjCCategoryDecl::instmeth_iterator I = CatClassDecl->instmeth_begin(),
Steve Naroff2ce399a2007-12-14 23:37:57 +0000557 E = CatClassDecl->instmeth_end(); I != E; ++I)
Steve Naroffb4f48512008-02-10 21:38:56 +0000558 if (!InsMap.count((*I)->getSelector()))
559 WarnUndefinedMethod(CatImplDecl->getLocation(), *I, IncompleteImpl);
560
Chris Lattner855e51f2007-12-12 07:09:47 +0000561 llvm::DenseSet<Selector> ClsMap;
562 // Check and see if class methods in category interface have been
563 // implemented in its implementation class.
Ted Kremenek42730c52008-01-07 19:49:32 +0000564 for (ObjCCategoryImplDecl::classmeth_iterator
Chris Lattner9d76c722007-12-12 17:58:05 +0000565 I = CatImplDecl->classmeth_begin(), E = CatImplDecl->classmeth_end();
566 I != E; ++I)
567 ClsMap.insert((*I)->getSelector());
Chris Lattner855e51f2007-12-12 07:09:47 +0000568
Ted Kremenek42730c52008-01-07 19:49:32 +0000569 for (ObjCCategoryDecl::classmeth_iterator I = CatClassDecl->classmeth_begin(),
Steve Naroff2ce399a2007-12-14 23:37:57 +0000570 E = CatClassDecl->classmeth_end(); I != E; ++I)
Steve Naroffb4f48512008-02-10 21:38:56 +0000571 if (!ClsMap.count((*I)->getSelector()))
572 WarnUndefinedMethod(CatImplDecl->getLocation(), *I, IncompleteImpl);
Chris Lattner855e51f2007-12-12 07:09:47 +0000573
574 // Check the protocol list for unimplemented methods in the @implementation
575 // class.
Ted Kremenek42730c52008-01-07 19:49:32 +0000576 ObjCProtocolDecl** protocols = CatClassDecl->getReferencedProtocols();
Fariborz Jahanian87829072007-12-20 19:24:10 +0000577 for (unsigned i = 0; i < CatClassDecl->getNumReferencedProtocols(); i++) {
Ted Kremenek42730c52008-01-07 19:49:32 +0000578 ObjCProtocolDecl* PDecl = protocols[i];
Steve Naroffb268d2a2008-02-08 22:06:17 +0000579 CheckProtocolMethodDefs(CatImplDecl->getLocation(), PDecl, IncompleteImpl,
580 InsMap, ClsMap);
Chris Lattner855e51f2007-12-12 07:09:47 +0000581 }
Chris Lattner855e51f2007-12-12 07:09:47 +0000582}
583
584/// ActOnForwardClassDeclaration -
585Action::DeclTy *
586Sema::ActOnForwardClassDeclaration(SourceLocation AtClassLoc,
587 IdentifierInfo **IdentList, unsigned NumElts)
588{
Ted Kremenek42730c52008-01-07 19:49:32 +0000589 llvm::SmallVector<ObjCInterfaceDecl*, 32> Interfaces;
Chris Lattner855e51f2007-12-12 07:09:47 +0000590
591 for (unsigned i = 0; i != NumElts; ++i) {
592 // Check for another declaration kind with the same name.
593 ScopedDecl *PrevDecl = LookupInterfaceDecl(IdentList[i]);
Ted Kremenek42730c52008-01-07 19:49:32 +0000594 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
Chris Lattner855e51f2007-12-12 07:09:47 +0000595 Diag(AtClassLoc, diag::err_redefinition_different_kind,
596 IdentList[i]->getName());
597 Diag(PrevDecl->getLocation(), diag::err_previous_definition);
598 }
Ted Kremenek42730c52008-01-07 19:49:32 +0000599 ObjCInterfaceDecl *IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
Chris Lattner855e51f2007-12-12 07:09:47 +0000600 if (!IDecl) { // Not already seen? Make a forward decl.
Chris Lattner0db541b2008-03-16 01:15:50 +0000601 IDecl = ObjCInterfaceDecl::Create(Context, AtClassLoc, 0, IdentList[i],
602 true);
Chris Lattner855e51f2007-12-12 07:09:47 +0000603 // Chain & install the interface decl into the identifier.
604 IDecl->setNext(IdentList[i]->getFETokenInfo<ScopedDecl>());
605 IdentList[i]->setFETokenInfo(IDecl);
606
607 // Remember that this needs to be removed when the scope is popped.
608 TUScope->AddDecl(IDecl);
609 }
610
611 Interfaces.push_back(IDecl);
612 }
613
Chris Lattnere29dc832008-03-16 20:34:23 +0000614 return ObjCClassDecl::Create(Context, AtClassLoc,
615 &Interfaces[0], Interfaces.size());
Chris Lattner855e51f2007-12-12 07:09:47 +0000616}
617
618
619/// MatchTwoMethodDeclarations - Checks that two methods have matching type and
620/// returns true, or false, accordingly.
621/// TODO: Handle protocol list; such as id<p1,p2> in type comparisons
Ted Kremenek42730c52008-01-07 19:49:32 +0000622bool Sema::MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,
623 const ObjCMethodDecl *PrevMethod) {
Chris Lattner855e51f2007-12-12 07:09:47 +0000624 if (Method->getResultType().getCanonicalType() !=
625 PrevMethod->getResultType().getCanonicalType())
626 return false;
Chris Lattner685d7922008-03-16 01:07:14 +0000627 for (unsigned i = 0, e = Method->getNumParams(); i != e; ++i) {
Chris Lattner855e51f2007-12-12 07:09:47 +0000628 ParmVarDecl *ParamDecl = Method->getParamDecl(i);
629 ParmVarDecl *PrevParamDecl = PrevMethod->getParamDecl(i);
630 if (ParamDecl->getCanonicalType() != PrevParamDecl->getCanonicalType())
631 return false;
632 }
633 return true;
634}
635
Ted Kremenek42730c52008-01-07 19:49:32 +0000636void Sema::AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method) {
637 ObjCMethodList &FirstMethod = InstanceMethodPool[Method->getSelector()];
Chris Lattner855e51f2007-12-12 07:09:47 +0000638 if (!FirstMethod.Method) {
639 // Haven't seen a method with this selector name yet - add it.
640 FirstMethod.Method = Method;
641 FirstMethod.Next = 0;
642 } else {
643 // We've seen a method with this name, now check the type signature(s).
644 bool match = MatchTwoMethodDeclarations(Method, FirstMethod.Method);
645
Ted Kremenek42730c52008-01-07 19:49:32 +0000646 for (ObjCMethodList *Next = FirstMethod.Next; !match && Next;
Chris Lattner855e51f2007-12-12 07:09:47 +0000647 Next = Next->Next)
648 match = MatchTwoMethodDeclarations(Method, Next->Method);
649
650 if (!match) {
651 // We have a new signature for an existing method - add it.
652 // This is extremely rare. Only 1% of Cocoa selectors are "overloaded".
Ted Kremenek42730c52008-01-07 19:49:32 +0000653 struct ObjCMethodList *OMI = new ObjCMethodList(Method, FirstMethod.Next);
Chris Lattner855e51f2007-12-12 07:09:47 +0000654 FirstMethod.Next = OMI;
655 }
656 }
657}
658
Ted Kremenek42730c52008-01-07 19:49:32 +0000659void Sema::AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method) {
660 ObjCMethodList &FirstMethod = FactoryMethodPool[Method->getSelector()];
Chris Lattner855e51f2007-12-12 07:09:47 +0000661 if (!FirstMethod.Method) {
662 // Haven't seen a method with this selector name yet - add it.
663 FirstMethod.Method = Method;
664 FirstMethod.Next = 0;
665 } else {
666 // We've seen a method with this name, now check the type signature(s).
667 bool match = MatchTwoMethodDeclarations(Method, FirstMethod.Method);
668
Ted Kremenek42730c52008-01-07 19:49:32 +0000669 for (ObjCMethodList *Next = FirstMethod.Next; !match && Next;
Chris Lattner855e51f2007-12-12 07:09:47 +0000670 Next = Next->Next)
671 match = MatchTwoMethodDeclarations(Method, Next->Method);
672
673 if (!match) {
674 // We have a new signature for an existing method - add it.
675 // This is extremely rare. Only 1% of Cocoa selectors are "overloaded".
Ted Kremenek42730c52008-01-07 19:49:32 +0000676 struct ObjCMethodList *OMI = new ObjCMethodList(Method, FirstMethod.Next);
Chris Lattner855e51f2007-12-12 07:09:47 +0000677 FirstMethod.Next = OMI;
678 }
679 }
680}
681
Steve Narofffe9eb6a2007-12-18 01:30:32 +0000682// Note: For class/category implemenations, allMethods/allProperties is
683// always null.
Chris Lattner855e51f2007-12-12 07:09:47 +0000684void Sema::ActOnAtEnd(SourceLocation AtEndLoc, DeclTy *classDecl,
685 DeclTy **allMethods, unsigned allNum,
686 DeclTy **allProperties, unsigned pNum) {
687 Decl *ClassDecl = static_cast<Decl *>(classDecl);
688
Steve Narofffe9eb6a2007-12-18 01:30:32 +0000689 // FIXME: If we don't have a ClassDecl, we have an error. We should consider
690 // always passing in a decl. If the decl has an error, isInvalidDecl()
Chris Lattner855e51f2007-12-12 07:09:47 +0000691 // should be true.
692 if (!ClassDecl)
693 return;
694
Ted Kremenek42730c52008-01-07 19:49:32 +0000695 llvm::SmallVector<ObjCMethodDecl*, 32> insMethods;
696 llvm::SmallVector<ObjCMethodDecl*, 16> clsMethods;
Chris Lattner855e51f2007-12-12 07:09:47 +0000697
Ted Kremenek42730c52008-01-07 19:49:32 +0000698 llvm::DenseMap<Selector, const ObjCMethodDecl*> InsMap;
699 llvm::DenseMap<Selector, const ObjCMethodDecl*> ClsMap;
Chris Lattner855e51f2007-12-12 07:09:47 +0000700
701 bool isInterfaceDeclKind =
Ted Kremenek42730c52008-01-07 19:49:32 +0000702 (isa<ObjCInterfaceDecl>(ClassDecl) || isa<ObjCCategoryDecl>(ClassDecl)
703 || isa<ObjCProtocolDecl>(ClassDecl));
704 bool checkIdenticalMethods = isa<ObjCImplementationDecl>(ClassDecl);
Chris Lattner855e51f2007-12-12 07:09:47 +0000705
706 // TODO: property declaration in category and protocols.
Ted Kremenek42730c52008-01-07 19:49:32 +0000707 if (pNum != 0 && isa<ObjCInterfaceDecl>(ClassDecl)) {
708 ObjCPropertyDecl **properties = new ObjCPropertyDecl*[pNum];
709 memcpy(properties, allProperties, pNum*sizeof(ObjCPropertyDecl*));
710 dyn_cast<ObjCInterfaceDecl>(ClassDecl)->setPropertyDecls(properties);
711 dyn_cast<ObjCInterfaceDecl>(ClassDecl)->setNumPropertyDecl(pNum);
Chris Lattner855e51f2007-12-12 07:09:47 +0000712 }
713
714 for (unsigned i = 0; i < allNum; i++ ) {
Ted Kremenek42730c52008-01-07 19:49:32 +0000715 ObjCMethodDecl *Method =
716 cast_or_null<ObjCMethodDecl>(static_cast<Decl*>(allMethods[i]));
Chris Lattner855e51f2007-12-12 07:09:47 +0000717
718 if (!Method) continue; // Already issued a diagnostic.
719 if (Method->isInstance()) {
720 /// Check for instance method of the same name with incompatible types
Ted Kremenek42730c52008-01-07 19:49:32 +0000721 const ObjCMethodDecl *&PrevMethod = InsMap[Method->getSelector()];
Chris Lattner855e51f2007-12-12 07:09:47 +0000722 bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod)
723 : false;
724 if (isInterfaceDeclKind && PrevMethod && !match
725 || checkIdenticalMethods && match) {
726 Diag(Method->getLocation(), diag::error_duplicate_method_decl,
727 Method->getSelector().getName());
728 Diag(PrevMethod->getLocation(), diag::err_previous_declaration);
729 } else {
730 insMethods.push_back(Method);
731 InsMap[Method->getSelector()] = Method;
732 /// The following allows us to typecheck messages to "id".
733 AddInstanceMethodToGlobalPool(Method);
734 }
735 }
736 else {
737 /// Check for class method of the same name with incompatible types
Ted Kremenek42730c52008-01-07 19:49:32 +0000738 const ObjCMethodDecl *&PrevMethod = ClsMap[Method->getSelector()];
Chris Lattner855e51f2007-12-12 07:09:47 +0000739 bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod)
740 : false;
741 if (isInterfaceDeclKind && PrevMethod && !match
742 || checkIdenticalMethods && match) {
743 Diag(Method->getLocation(), diag::error_duplicate_method_decl,
744 Method->getSelector().getName());
745 Diag(PrevMethod->getLocation(), diag::err_previous_declaration);
746 } else {
747 clsMethods.push_back(Method);
748 ClsMap[Method->getSelector()] = Method;
Steve Narofffe9eb6a2007-12-18 01:30:32 +0000749 /// The following allows us to typecheck messages to "Class".
750 AddFactoryMethodToGlobalPool(Method);
Chris Lattner855e51f2007-12-12 07:09:47 +0000751 }
752 }
753 }
754
Ted Kremenek42730c52008-01-07 19:49:32 +0000755 if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) {
Chris Lattner855e51f2007-12-12 07:09:47 +0000756 I->addMethods(&insMethods[0], insMethods.size(),
757 &clsMethods[0], clsMethods.size(), AtEndLoc);
Ted Kremenek42730c52008-01-07 19:49:32 +0000758 } else if (ObjCProtocolDecl *P = dyn_cast<ObjCProtocolDecl>(ClassDecl)) {
Chris Lattner855e51f2007-12-12 07:09:47 +0000759 P->addMethods(&insMethods[0], insMethods.size(),
760 &clsMethods[0], clsMethods.size(), AtEndLoc);
761 }
Ted Kremenek42730c52008-01-07 19:49:32 +0000762 else if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(ClassDecl)) {
Chris Lattner855e51f2007-12-12 07:09:47 +0000763 C->addMethods(&insMethods[0], insMethods.size(),
764 &clsMethods[0], clsMethods.size(), AtEndLoc);
765 }
Ted Kremenek42730c52008-01-07 19:49:32 +0000766 else if (ObjCImplementationDecl *IC =
767 dyn_cast<ObjCImplementationDecl>(ClassDecl)) {
Chris Lattner855e51f2007-12-12 07:09:47 +0000768 IC->setLocEnd(AtEndLoc);
Ted Kremenek42730c52008-01-07 19:49:32 +0000769 if (ObjCInterfaceDecl* IDecl = getObjCInterfaceDecl(IC->getIdentifier()))
Chris Lattner855e51f2007-12-12 07:09:47 +0000770 ImplMethodsVsClassMethods(IC, IDecl);
771 } else {
Ted Kremenek42730c52008-01-07 19:49:32 +0000772 ObjCCategoryImplDecl* CatImplClass = cast<ObjCCategoryImplDecl>(ClassDecl);
Chris Lattner855e51f2007-12-12 07:09:47 +0000773 CatImplClass->setLocEnd(AtEndLoc);
Ted Kremenek42730c52008-01-07 19:49:32 +0000774 ObjCInterfaceDecl* IDecl = CatImplClass->getClassInterface();
Chris Lattner855e51f2007-12-12 07:09:47 +0000775 // Find category interface decl and then check that all methods declared
776 // in this interface is implemented in the category @implementation.
777 if (IDecl) {
Ted Kremenek42730c52008-01-07 19:49:32 +0000778 for (ObjCCategoryDecl *Categories = IDecl->getCategoryList();
Chris Lattner855e51f2007-12-12 07:09:47 +0000779 Categories; Categories = Categories->getNextClassCategory()) {
780 if (Categories->getIdentifier() == CatImplClass->getIdentifier()) {
781 ImplCategoryMethodsVsIntfMethods(CatImplClass, Categories);
782 break;
783 }
784 }
785 }
786 }
787}
788
789
790/// CvtQTToAstBitMask - utility routine to produce an AST bitmask for
791/// objective-c's type qualifier from the parser version of the same info.
Ted Kremenek42730c52008-01-07 19:49:32 +0000792static Decl::ObjCDeclQualifier
793CvtQTToAstBitMask(ObjCDeclSpec::ObjCDeclQualifier PQTVal) {
794 Decl::ObjCDeclQualifier ret = Decl::OBJC_TQ_None;
795 if (PQTVal & ObjCDeclSpec::DQ_In)
796 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_In);
797 if (PQTVal & ObjCDeclSpec::DQ_Inout)
798 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Inout);
799 if (PQTVal & ObjCDeclSpec::DQ_Out)
800 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Out);
801 if (PQTVal & ObjCDeclSpec::DQ_Bycopy)
802 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Bycopy);
803 if (PQTVal & ObjCDeclSpec::DQ_Byref)
804 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Byref);
805 if (PQTVal & ObjCDeclSpec::DQ_Oneway)
806 ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Oneway);
Chris Lattner855e51f2007-12-12 07:09:47 +0000807
808 return ret;
809}
810
811Sema::DeclTy *Sema::ActOnMethodDeclaration(
812 SourceLocation MethodLoc, SourceLocation EndLoc,
Chris Lattner114add62008-03-16 00:49:28 +0000813 tok::TokenKind MethodType, DeclTy *classDecl,
Ted Kremenek42730c52008-01-07 19:49:32 +0000814 ObjCDeclSpec &ReturnQT, TypeTy *ReturnType,
Chris Lattner855e51f2007-12-12 07:09:47 +0000815 Selector Sel,
816 // optional arguments. The number of types/arguments is obtained
817 // from the Sel.getNumArgs().
Ted Kremenek42730c52008-01-07 19:49:32 +0000818 ObjCDeclSpec *ArgQT, TypeTy **ArgTypes, IdentifierInfo **ArgNames,
Chris Lattner855e51f2007-12-12 07:09:47 +0000819 AttributeList *AttrList, tok::ObjCKeywordKind MethodDeclKind,
820 bool isVariadic) {
Chris Lattner114add62008-03-16 00:49:28 +0000821 Decl *ClassDecl = static_cast<Decl*>(classDecl);
Steve Naroff70f16242008-02-29 21:48:07 +0000822
823 // Make sure we can establish a context for the method.
824 if (!ClassDecl) {
825 Diag(MethodLoc, diag::error_missing_method_context);
826 return 0;
827 }
Chris Lattner855e51f2007-12-12 07:09:47 +0000828 llvm::SmallVector<ParmVarDecl*, 16> Params;
829
830 for (unsigned i = 0; i < Sel.getNumArgs(); i++) {
831 // FIXME: arg->AttrList must be stored too!
832 QualType argType;
833
834 if (ArgTypes[i])
835 argType = QualType::getFromOpaquePtr(ArgTypes[i]);
836 else
Ted Kremenek42730c52008-01-07 19:49:32 +0000837 argType = Context.getObjCIdType();
Chris Lattner58114f02008-03-15 21:32:50 +0000838 ParmVarDecl* Param = ParmVarDecl::Create(Context, SourceLocation(/*FIXME*/),
Chris Lattner48d225c2008-03-15 21:10:16 +0000839 ArgNames[i], argType,
Chris Lattner58114f02008-03-15 21:32:50 +0000840 VarDecl::None, 0);
Ted Kremenek42730c52008-01-07 19:49:32 +0000841 Param->setObjCDeclQualifier(
842 CvtQTToAstBitMask(ArgQT[i].getObjCDeclQualifier()));
Chris Lattner855e51f2007-12-12 07:09:47 +0000843 Params.push_back(Param);
844 }
845 QualType resultDeclType;
846
847 if (ReturnType)
848 resultDeclType = QualType::getFromOpaquePtr(ReturnType);
849 else // get the type for "id".
Ted Kremenek42730c52008-01-07 19:49:32 +0000850 resultDeclType = Context.getObjCIdType();
Chris Lattner855e51f2007-12-12 07:09:47 +0000851
Chris Lattner114add62008-03-16 00:49:28 +0000852 ObjCMethodDecl* ObjCMethod =
853 ObjCMethodDecl::Create(Context, MethodLoc, EndLoc, Sel, resultDeclType,
Chris Lattnerf7355832008-03-16 00:58:16 +0000854 ClassDecl, AttrList,
Chris Lattner114add62008-03-16 00:49:28 +0000855 MethodType == tok::minus, isVariadic,
856 MethodDeclKind == tok::objc_optional ?
857 ObjCMethodDecl::Optional :
858 ObjCMethodDecl::Required);
859
Ted Kremenek42730c52008-01-07 19:49:32 +0000860 ObjCMethod->setMethodParams(&Params[0], Sel.getNumArgs());
861 ObjCMethod->setObjCDeclQualifier(
862 CvtQTToAstBitMask(ReturnQT.getObjCDeclQualifier()));
863 const ObjCMethodDecl *PrevMethod = 0;
Chris Lattner855e51f2007-12-12 07:09:47 +0000864
865 // For implementations (which can be very "coarse grain"), we add the
866 // method now. This allows the AST to implement lookup methods that work
867 // incrementally (without waiting until we parse the @end). It also allows
868 // us to flag multiple declaration errors as they occur.
Ted Kremenek42730c52008-01-07 19:49:32 +0000869 if (ObjCImplementationDecl *ImpDecl =
Chris Lattner114add62008-03-16 00:49:28 +0000870 dyn_cast<ObjCImplementationDecl>(ClassDecl)) {
Chris Lattner855e51f2007-12-12 07:09:47 +0000871 if (MethodType == tok::minus) {
Steve Naroff74273de2007-12-19 22:27:04 +0000872 PrevMethod = ImpDecl->getInstanceMethod(Sel);
Ted Kremenek42730c52008-01-07 19:49:32 +0000873 ImpDecl->addInstanceMethod(ObjCMethod);
Chris Lattner855e51f2007-12-12 07:09:47 +0000874 } else {
Steve Naroff74273de2007-12-19 22:27:04 +0000875 PrevMethod = ImpDecl->getClassMethod(Sel);
Ted Kremenek42730c52008-01-07 19:49:32 +0000876 ImpDecl->addClassMethod(ObjCMethod);
Chris Lattner855e51f2007-12-12 07:09:47 +0000877 }
878 }
Ted Kremenek42730c52008-01-07 19:49:32 +0000879 else if (ObjCCategoryImplDecl *CatImpDecl =
Chris Lattner114add62008-03-16 00:49:28 +0000880 dyn_cast<ObjCCategoryImplDecl>(ClassDecl)) {
Chris Lattner855e51f2007-12-12 07:09:47 +0000881 if (MethodType == tok::minus) {
Steve Naroff74273de2007-12-19 22:27:04 +0000882 PrevMethod = CatImpDecl->getInstanceMethod(Sel);
Ted Kremenek42730c52008-01-07 19:49:32 +0000883 CatImpDecl->addInstanceMethod(ObjCMethod);
Chris Lattner855e51f2007-12-12 07:09:47 +0000884 } else {
Steve Naroff74273de2007-12-19 22:27:04 +0000885 PrevMethod = CatImpDecl->getClassMethod(Sel);
Ted Kremenek42730c52008-01-07 19:49:32 +0000886 CatImpDecl->addClassMethod(ObjCMethod);
Chris Lattner855e51f2007-12-12 07:09:47 +0000887 }
888 }
889 if (PrevMethod) {
890 // You can never have two method definitions with the same name.
Ted Kremenek42730c52008-01-07 19:49:32 +0000891 Diag(ObjCMethod->getLocation(), diag::error_duplicate_method_decl,
892 ObjCMethod->getSelector().getName());
Chris Lattner855e51f2007-12-12 07:09:47 +0000893 Diag(PrevMethod->getLocation(), diag::err_previous_declaration);
894 }
Ted Kremenek42730c52008-01-07 19:49:32 +0000895 return ObjCMethod;
Chris Lattner855e51f2007-12-12 07:09:47 +0000896}
897
Ted Kremenek42730c52008-01-07 19:49:32 +0000898Sema::DeclTy *Sema::ActOnAddObjCProperties(SourceLocation AtLoc,
899 DeclTy **allProperties, unsigned NumProperties, ObjCDeclSpec &DS) {
900 ObjCPropertyDecl *PDecl = new ObjCPropertyDecl(AtLoc);
Chris Lattner855e51f2007-12-12 07:09:47 +0000901
Ted Kremenek42730c52008-01-07 19:49:32 +0000902 if(DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_readonly)
903 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readonly);
Chris Lattner855e51f2007-12-12 07:09:47 +0000904
Ted Kremenek42730c52008-01-07 19:49:32 +0000905 if(DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_getter) {
906 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_getter);
Chris Lattner855e51f2007-12-12 07:09:47 +0000907 PDecl->setGetterName(DS.getGetterName());
908 }
909
Ted Kremenek42730c52008-01-07 19:49:32 +0000910 if(DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_setter) {
911 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_setter);
Chris Lattner855e51f2007-12-12 07:09:47 +0000912 PDecl->setSetterName(DS.getSetterName());
913 }
914
Ted Kremenek42730c52008-01-07 19:49:32 +0000915 if(DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_assign)
916 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_assign);
Chris Lattner855e51f2007-12-12 07:09:47 +0000917
Ted Kremenek42730c52008-01-07 19:49:32 +0000918 if(DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_readwrite)
919 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readwrite);
Chris Lattner855e51f2007-12-12 07:09:47 +0000920
Ted Kremenek42730c52008-01-07 19:49:32 +0000921 if(DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_retain)
922 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_retain);
Chris Lattner855e51f2007-12-12 07:09:47 +0000923
Ted Kremenek42730c52008-01-07 19:49:32 +0000924 if(DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_copy)
925 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_copy);
Chris Lattner855e51f2007-12-12 07:09:47 +0000926
Ted Kremenek42730c52008-01-07 19:49:32 +0000927 if(DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_nonatomic)
928 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_nonatomic);
Chris Lattner855e51f2007-12-12 07:09:47 +0000929
930 PDecl->setNumPropertyDecls(NumProperties);
931 if (NumProperties != 0) {
Ted Kremenek42730c52008-01-07 19:49:32 +0000932 ObjCIvarDecl **properties = new ObjCIvarDecl*[NumProperties];
933 memcpy(properties, allProperties, NumProperties*sizeof(ObjCIvarDecl*));
Chris Lattner855e51f2007-12-12 07:09:47 +0000934 PDecl->setPropertyDecls(properties);
935 }
936 return PDecl;
937}
938