SemaDeclObjC.cpp revision 180f7e2b7bab938bc797f3ed459826720866655a 
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(CurFunctionDecl == 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  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;
45  PI.AttrList = 0;
46  PI.TypeInfo = Context.getObjCIdType().getAsOpaquePtr();
47
48  if (MDecl->isInstance()) {
49    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
52      QualType selfTy = Context.getObjCInterfaceType(OID);
53      selfTy = Context.getPointerType(selfTy);
54      PI.TypeInfo = selfTy.getAsOpaquePtr();
55    }
56  }
57
58  CurMethodDecl->setSelfDecl(ActOnParamDeclarator(PI, FnBodyScope));
59
60  PI.Ident = &Context.Idents.get("_cmd");
61  PI.TypeInfo = Context.getObjCSelType().getAsOpaquePtr();
62  ActOnParamDeclarator(PI, FnBodyScope);
63
64  for (unsigned i = 0, e = MDecl->getNumParams(); i != e; ++i) {
65    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();
69    MDecl->setParamDecl(i, ActOnParamDeclarator(PI, FnBodyScope));
70  }
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);
83  if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
84    Diag(ClassLoc, diag::err_redefinition_different_kind,
85         ClassName->getName());
86    Diag(PrevDecl->getLocation(), diag::err_previous_definition);
87  }
88
89  ObjCInterfaceDecl* IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
90  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 {
101    IDecl = ObjCInterfaceDecl::Create(Context, AtInterfaceLoc, NumProtocols,
102                                      ClassName);
103
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) {
113    ObjCInterfaceDecl* SuperClassEntry = 0;
114    // Check if a different kind of symbol declared in this scope.
115    PrevDecl = LookupInterfaceDecl(SuperName);
116    if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
117      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
123      SuperClassEntry = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
124
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++) {
141      ObjCProtocolDecl* RefPDecl = ObjCProtocols[ProtocolNames[i]];
142      if (!RefPDecl || RefPDecl->isForwardDecl())
143        Diag(ClassLoc, diag::warn_undef_protocolref,
144             ProtocolNames[i]->getName(),
145             ClassName->getName());
146      IDecl->setIntfRefProtocols(i, RefPDecl);
147    }
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) {
163    if (isa<ObjCCompatibleAliasDecl>(ADecl)) {
164      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);
177  if (!CDecl || !isa<ObjCInterfaceDecl>(CDecl)) {
178    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
185  ObjCCompatibleAliasDecl *AliasDecl =
186    new ObjCCompatibleAliasDecl(AtCompatibilityAliasLoc,
187                                AliasName,
188                                dyn_cast<ObjCInterfaceDecl>(CDecl));
189
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");
202  ObjCProtocolDecl *PDecl = ObjCProtocols[ProtocolName];
203  if (PDecl) {
204    // Protocol already seen. Better be a forward protocol declaration
205    if (!PDecl->isForwardDecl())
206      Diag(ProtocolLoc, diag::err_duplicate_protocol_def,
207           ProtocolName->getName());
208    else {
209      PDecl->setForwardDecl(false);
210      PDecl->AllocReferencedProtocols(NumProtoRefs);
211    }
212  }
213  else {
214    PDecl = ObjCProtocolDecl::Create(Context, AtProtoInterfaceLoc, NumProtoRefs,
215                                     ProtocolName);
216    ObjCProtocols[ProtocolName] = PDecl;
217  }
218
219  if (NumProtoRefs) {
220    /// Check then save referenced protocols
221    for (unsigned int i = 0; i != NumProtoRefs; i++) {
222      ObjCProtocolDecl* RefPDecl = ObjCProtocols[ProtoRefNames[i]];
223      if (!RefPDecl || RefPDecl->isForwardDecl())
224        Diag(ProtocolLoc, diag::warn_undef_protocolref,
225             ProtoRefNames[i]->getName(),
226             ProtocolName->getName());
227      PDecl->setReferencedProtocols(i, RefPDecl);
228    }
229    PDecl->setLocEnd(EndProtoLoc);
230  }
231  return PDecl;
232}
233
234/// FindProtocolDeclaration - This routine looks up protocols and
235/// issuer error if they are not declared. It returns list of protocol
236/// declarations in its 'Protocols' argument.
237void
238Sema::FindProtocolDeclaration(SourceLocation TypeLoc,
239                              IdentifierInfo **ProtocolId,
240                              unsigned NumProtocols,
241                              llvm::SmallVector<DeclTy *,8> &Protocols) {
242  for (unsigned i = 0; i != NumProtocols; ++i) {
243    ObjCProtocolDecl *PDecl = ObjCProtocols[ProtocolId[i]];
244    if (!PDecl)
245      Diag(TypeLoc, diag::err_undeclared_protocol,
246           ProtocolId[i]->getName());
247    else
248      Protocols.push_back(PDecl);
249  }
250}
251
252/// ActOnForwardProtocolDeclaration -
253Action::DeclTy *
254Sema::ActOnForwardProtocolDeclaration(SourceLocation AtProtocolLoc,
255        IdentifierInfo **IdentList, unsigned NumElts) {
256  llvm::SmallVector<ObjCProtocolDecl*, 32> Protocols;
257
258  for (unsigned i = 0; i != NumElts; ++i) {
259    IdentifierInfo *P = IdentList[i];
260    ObjCProtocolDecl *PDecl = ObjCProtocols[P];
261    if (!PDecl)  { // Not already seen?
262      // FIXME: Pass in the location of the identifier!
263      PDecl = ObjCProtocolDecl::Create(Context, AtProtocolLoc, 0, P, true);
264      ObjCProtocols[P] = PDecl;
265    }
266
267    Protocols.push_back(PDecl);
268  }
269  return new ObjCForwardProtocolDecl(AtProtocolLoc,
270                                     &Protocols[0], Protocols.size());
271}
272
273Sema::DeclTy *Sema::ActOnStartCategoryInterface(
274                      SourceLocation AtInterfaceLoc,
275                      IdentifierInfo *ClassName, SourceLocation ClassLoc,
276                      IdentifierInfo *CategoryName, SourceLocation CategoryLoc,
277                      IdentifierInfo **ProtoRefNames, unsigned NumProtoRefs,
278                      SourceLocation EndProtoLoc) {
279  ObjCInterfaceDecl *IDecl = getObjCInterfaceDecl(ClassName);
280
281  ObjCCategoryDecl *CDecl = new ObjCCategoryDecl(AtInterfaceLoc, NumProtoRefs,
282                                                 CategoryName);
283  CDecl->setClassInterface(IDecl);
284
285  /// Check that class of this category is already completely declared.
286  if (!IDecl || IDecl->isForwardDecl())
287    Diag(ClassLoc, diag::err_undef_interface, ClassName->getName());
288  else {
289    /// Check for duplicate interface declaration for this category
290    ObjCCategoryDecl *CDeclChain;
291    for (CDeclChain = IDecl->getCategoryList(); CDeclChain;
292         CDeclChain = CDeclChain->getNextClassCategory()) {
293      if (CDeclChain->getIdentifier() == CategoryName) {
294        Diag(CategoryLoc, diag::err_dup_category_def, ClassName->getName(),
295             CategoryName->getName());
296        break;
297      }
298    }
299  if (!CDeclChain)
300    CDecl->insertNextClassCategory();
301  }
302
303  if (NumProtoRefs) {
304    /// Check then save referenced protocols
305    for (unsigned int i = 0; i != NumProtoRefs; i++) {
306      ObjCProtocolDecl* RefPDecl = ObjCProtocols[ProtoRefNames[i]];
307      if (!RefPDecl || RefPDecl->isForwardDecl()) {
308        Diag(CategoryLoc, diag::warn_undef_protocolref,
309             ProtoRefNames[i]->getName(),
310             CategoryName->getName());
311      }
312      CDecl->setCatReferencedProtocols(i, RefPDecl);
313    }
314    CDecl->setLocEnd(EndProtoLoc);
315  }
316  return CDecl;
317}
318
319/// ActOnStartCategoryImplementation - Perform semantic checks on the
320/// category implementation declaration and build an ObjCCategoryImplDecl
321/// object.
322Sema::DeclTy *Sema::ActOnStartCategoryImplementation(
323                      SourceLocation AtCatImplLoc,
324                      IdentifierInfo *ClassName, SourceLocation ClassLoc,
325                      IdentifierInfo *CatName, SourceLocation CatLoc) {
326  ObjCInterfaceDecl *IDecl = getObjCInterfaceDecl(ClassName);
327  ObjCCategoryImplDecl *CDecl = new ObjCCategoryImplDecl(AtCatImplLoc,
328                                                         CatName, IDecl);
329  /// Check that class of this category is already completely declared.
330  if (!IDecl || IDecl->isForwardDecl())
331    Diag(ClassLoc, diag::err_undef_interface, ClassName->getName());
332
333  /// TODO: Check that CatName, category name, is not used in another
334  // implementation.
335  return CDecl;
336}
337
338Sema::DeclTy *Sema::ActOnStartClassImplementation(
339                      SourceLocation AtClassImplLoc,
340                      IdentifierInfo *ClassName, SourceLocation ClassLoc,
341                      IdentifierInfo *SuperClassname,
342                      SourceLocation SuperClassLoc) {
343  ObjCInterfaceDecl* IDecl = 0;
344  // Check for another declaration kind with the same name.
345  ScopedDecl *PrevDecl = LookupInterfaceDecl(ClassName);
346  if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
347    Diag(ClassLoc, diag::err_redefinition_different_kind,
348         ClassName->getName());
349    Diag(PrevDecl->getLocation(), diag::err_previous_definition);
350  }
351  else {
352    // Is there an interface declaration of this class; if not, warn!
353    IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
354    if (!IDecl)
355      Diag(ClassLoc, diag::warn_undef_interface, ClassName->getName());
356  }
357
358  // Check that super class name is valid class name
359  ObjCInterfaceDecl* SDecl = 0;
360  if (SuperClassname) {
361    // Check if a different kind of symbol declared in this scope.
362    PrevDecl = LookupInterfaceDecl(SuperClassname);
363    if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
364      Diag(SuperClassLoc, diag::err_redefinition_different_kind,
365           SuperClassname->getName());
366      Diag(PrevDecl->getLocation(), diag::err_previous_definition);
367    }
368    else {
369      SDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
370      if (!SDecl)
371        Diag(SuperClassLoc, diag::err_undef_superclass,
372             SuperClassname->getName(), ClassName->getName());
373      else if (IDecl && IDecl->getSuperClass() != SDecl) {
374        // This implementation and its interface do not have the same
375        // super class.
376        Diag(SuperClassLoc, diag::err_conflicting_super_class,
377             SDecl->getName());
378        Diag(SDecl->getLocation(), diag::err_previous_definition);
379      }
380    }
381  }
382
383  if (!IDecl) {
384    // Legacy case of @implementation with no corresponding @interface.
385    // Build, chain & install the interface decl into the identifier.
386    IDecl = ObjCInterfaceDecl::Create(Context, AtClassImplLoc, 0, ClassName,
387                                      false, true);
388    IDecl->setNext(ClassName->getFETokenInfo<ScopedDecl>());
389    ClassName->setFETokenInfo(IDecl);
390    IDecl->setSuperClass(SDecl);
391    IDecl->setLocEnd(ClassLoc);
392
393    // Remember that this needs to be removed when the scope is popped.
394    TUScope->AddDecl(IDecl);
395  }
396
397  ObjCImplementationDecl* IMPDecl =
398  new ObjCImplementationDecl(AtClassImplLoc, ClassName, IDecl, SDecl);
399
400  // Check that there is no duplicate implementation of this class.
401  if (ObjCImplementations[ClassName])
402    Diag(ClassLoc, diag::err_dup_implementation_class, ClassName->getName());
403  else // add it to the list.
404    ObjCImplementations[ClassName] = IMPDecl;
405  return IMPDecl;
406}
407
408void Sema::CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
409                                    ObjCIvarDecl **ivars, unsigned numIvars,
410                                    SourceLocation RBrace) {
411  assert(ImpDecl && "missing implementation decl");
412  ObjCInterfaceDecl* IDecl = getObjCInterfaceDecl(ImpDecl->getIdentifier());
413  if (!IDecl)
414    return;
415  /// Check case of non-existing @interface decl.
416  /// (legacy objective-c @implementation decl without an @interface decl).
417  /// Add implementations's ivar to the synthesize class's ivar list.
418  if (IDecl->ImplicitInterfaceDecl()) {
419    IDecl->addInstanceVariablesToClass(ivars, numIvars, RBrace);
420    return;
421  }
422  // If implementation has empty ivar list, just return.
423  if (numIvars == 0)
424    return;
425
426  assert(ivars && "missing @implementation ivars");
427
428  // Check interface's Ivar list against those in the implementation.
429  // names and types must match.
430  //
431  unsigned j = 0;
432  ObjCInterfaceDecl::ivar_iterator
433    IVI = IDecl->ivar_begin(), IVE = IDecl->ivar_end();
434  for (; numIvars > 0 && IVI != IVE; ++IVI) {
435    ObjCIvarDecl* ImplIvar = ivars[j++];
436    ObjCIvarDecl* ClsIvar = *IVI;
437    assert (ImplIvar && "missing implementation ivar");
438    assert (ClsIvar && "missing class ivar");
439    if (ImplIvar->getCanonicalType() != ClsIvar->getCanonicalType()) {
440      Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_type,
441           ImplIvar->getIdentifier()->getName());
442      Diag(ClsIvar->getLocation(), diag::err_previous_definition,
443           ClsIvar->getIdentifier()->getName());
444    }
445    // TODO: Two mismatched (unequal width) Ivar bitfields should be diagnosed
446    // as error.
447    else if (ImplIvar->getIdentifier() != ClsIvar->getIdentifier()) {
448      Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_name,
449           ImplIvar->getIdentifier()->getName());
450      Diag(ClsIvar->getLocation(), diag::err_previous_definition,
451           ClsIvar->getIdentifier()->getName());
452      return;
453    }
454    --numIvars;
455  }
456
457  if (numIvars > 0)
458    Diag(ivars[j]->getLocation(), diag::err_inconsistant_ivar_count);
459  else if (IVI != IVE)
460    Diag((*IVI)->getLocation(), diag::err_inconsistant_ivar_count);
461}
462
463void Sema::WarnUndefinedMethod(SourceLocation ImpLoc, ObjCMethodDecl *method,
464                               bool &IncompleteImpl) {
465  if (!IncompleteImpl) {
466    Diag(ImpLoc, diag::warn_incomplete_impl);
467    IncompleteImpl = true;
468  }
469  Diag(ImpLoc, diag::warn_undef_method_impl, method->getSelector().getName());
470}
471
472/// CheckProtocolMethodDefs - This routine checks unimplemented methods
473/// Declared in protocol, and those referenced by it.
474void Sema::CheckProtocolMethodDefs(SourceLocation ImpLoc,
475                                   ObjCProtocolDecl *PDecl,
476                                   bool& IncompleteImpl,
477                                   const llvm::DenseSet<Selector> &InsMap,
478                                   const llvm::DenseSet<Selector> &ClsMap) {
479  // check unimplemented instance methods.
480  for (ObjCProtocolDecl::instmeth_iterator I = PDecl->instmeth_begin(),
481       E = PDecl->instmeth_end(); I != E; ++I) {
482    ObjCMethodDecl *method = *I;
483    if (!InsMap.count(method->getSelector()) &&
484        method->getImplementationControl() != ObjCMethodDecl::Optional)
485      WarnUndefinedMethod(ImpLoc, method, IncompleteImpl);
486  }
487  // check unimplemented class methods
488  for (ObjCProtocolDecl::classmeth_iterator I = PDecl->classmeth_begin(),
489       E = PDecl->classmeth_end(); I != E; ++I) {
490    ObjCMethodDecl *method = *I;
491    if (!ClsMap.count(method->getSelector()) &&
492        method->getImplementationControl() != ObjCMethodDecl::Optional)
493      WarnUndefinedMethod(ImpLoc, method, IncompleteImpl);
494  }
495  // Check on this protocols's referenced protocols, recursively
496  ObjCProtocolDecl** RefPDecl = PDecl->getReferencedProtocols();
497  for (unsigned i = 0; i < PDecl->getNumReferencedProtocols(); i++)
498    CheckProtocolMethodDefs(ImpLoc, RefPDecl[i], IncompleteImpl, InsMap, ClsMap);
499}
500
501void Sema::ImplMethodsVsClassMethods(ObjCImplementationDecl* IMPDecl,
502                                     ObjCInterfaceDecl* IDecl) {
503  llvm::DenseSet<Selector> InsMap;
504  // Check and see if instance methods in class interface have been
505  // implemented in the implementation class.
506  for (ObjCImplementationDecl::instmeth_iterator I = IMPDecl->instmeth_begin(),
507       E = IMPDecl->instmeth_end(); I != E; ++I)
508    InsMap.insert((*I)->getSelector());
509
510  bool IncompleteImpl = false;
511  for (ObjCInterfaceDecl::instmeth_iterator I = IDecl->instmeth_begin(),
512       E = IDecl->instmeth_end(); I != E; ++I)
513    if (!InsMap.count((*I)->getSelector()))
514      WarnUndefinedMethod(IMPDecl->getLocation(), *I, IncompleteImpl);
515
516  llvm::DenseSet<Selector> ClsMap;
517  // Check and see if class methods in class interface have been
518  // implemented in the implementation class.
519  for (ObjCImplementationDecl::classmeth_iterator I =IMPDecl->classmeth_begin(),
520       E = IMPDecl->classmeth_end(); I != E; ++I)
521    ClsMap.insert((*I)->getSelector());
522
523  for (ObjCInterfaceDecl::classmeth_iterator I = IDecl->classmeth_begin(),
524       E = IDecl->classmeth_end(); I != E; ++I)
525    if (!ClsMap.count((*I)->getSelector()))
526      WarnUndefinedMethod(IMPDecl->getLocation(), *I, IncompleteImpl);
527
528  // Check the protocol list for unimplemented methods in the @implementation
529  // class.
530  ObjCProtocolDecl** protocols = IDecl->getReferencedProtocols();
531  for (unsigned i = 0; i < IDecl->getNumIntfRefProtocols(); i++)
532    CheckProtocolMethodDefs(IMPDecl->getLocation(), protocols[i],
533                            IncompleteImpl, InsMap, ClsMap);
534}
535
536/// ImplCategoryMethodsVsIntfMethods - Checks that methods declared in the
537/// category interface is implemented in the category @implementation.
538void Sema::ImplCategoryMethodsVsIntfMethods(ObjCCategoryImplDecl *CatImplDecl,
539                                            ObjCCategoryDecl *CatClassDecl) {
540  llvm::DenseSet<Selector> InsMap;
541  // Check and see if instance methods in category interface have been
542  // implemented in its implementation class.
543  for (ObjCCategoryImplDecl::instmeth_iterator I =CatImplDecl->instmeth_begin(),
544       E = CatImplDecl->instmeth_end(); I != E; ++I)
545    InsMap.insert((*I)->getSelector());
546
547  bool IncompleteImpl = false;
548  for (ObjCCategoryDecl::instmeth_iterator I = CatClassDecl->instmeth_begin(),
549       E = CatClassDecl->instmeth_end(); I != E; ++I)
550    if (!InsMap.count((*I)->getSelector()))
551      WarnUndefinedMethod(CatImplDecl->getLocation(), *I, IncompleteImpl);
552
553  llvm::DenseSet<Selector> ClsMap;
554  // Check and see if class methods in category interface have been
555  // implemented in its implementation class.
556  for (ObjCCategoryImplDecl::classmeth_iterator
557       I = CatImplDecl->classmeth_begin(), E = CatImplDecl->classmeth_end();
558       I != E; ++I)
559    ClsMap.insert((*I)->getSelector());
560
561  for (ObjCCategoryDecl::classmeth_iterator I = CatClassDecl->classmeth_begin(),
562       E = CatClassDecl->classmeth_end(); I != E; ++I)
563    if (!ClsMap.count((*I)->getSelector()))
564      WarnUndefinedMethod(CatImplDecl->getLocation(), *I, IncompleteImpl);
565
566  // Check the protocol list for unimplemented methods in the @implementation
567  // class.
568  ObjCProtocolDecl** protocols = CatClassDecl->getReferencedProtocols();
569  for (unsigned i = 0; i < CatClassDecl->getNumReferencedProtocols(); i++) {
570    ObjCProtocolDecl* PDecl = protocols[i];
571    CheckProtocolMethodDefs(CatImplDecl->getLocation(), PDecl, IncompleteImpl,
572                            InsMap, ClsMap);
573  }
574}
575
576/// ActOnForwardClassDeclaration -
577Action::DeclTy *
578Sema::ActOnForwardClassDeclaration(SourceLocation AtClassLoc,
579                                   IdentifierInfo **IdentList, unsigned NumElts)
580{
581  llvm::SmallVector<ObjCInterfaceDecl*, 32> Interfaces;
582
583  for (unsigned i = 0; i != NumElts; ++i) {
584    // Check for another declaration kind with the same name.
585    ScopedDecl *PrevDecl = LookupInterfaceDecl(IdentList[i]);
586    if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
587      Diag(AtClassLoc, diag::err_redefinition_different_kind,
588           IdentList[i]->getName());
589      Diag(PrevDecl->getLocation(), diag::err_previous_definition);
590    }
591    ObjCInterfaceDecl *IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
592    if (!IDecl) {  // Not already seen?  Make a forward decl.
593      IDecl = ObjCInterfaceDecl::Create(Context, AtClassLoc, 0, IdentList[i],
594                                        true);
595      // Chain & install the interface decl into the identifier.
596      IDecl->setNext(IdentList[i]->getFETokenInfo<ScopedDecl>());
597      IdentList[i]->setFETokenInfo(IDecl);
598
599      // Remember that this needs to be removed when the scope is popped.
600      TUScope->AddDecl(IDecl);
601    }
602
603    Interfaces.push_back(IDecl);
604  }
605
606  return new ObjCClassDecl(AtClassLoc, &Interfaces[0], Interfaces.size());
607}
608
609
610/// MatchTwoMethodDeclarations - Checks that two methods have matching type and
611/// returns true, or false, accordingly.
612/// TODO: Handle protocol list; such as id<p1,p2> in type comparisons
613bool Sema::MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,
614                                      const ObjCMethodDecl *PrevMethod) {
615  if (Method->getResultType().getCanonicalType() !=
616      PrevMethod->getResultType().getCanonicalType())
617    return false;
618  for (unsigned i = 0, e = Method->getNumParams(); i != e; ++i) {
619    ParmVarDecl *ParamDecl = Method->getParamDecl(i);
620    ParmVarDecl *PrevParamDecl = PrevMethod->getParamDecl(i);
621    if (ParamDecl->getCanonicalType() != PrevParamDecl->getCanonicalType())
622      return false;
623  }
624  return true;
625}
626
627void Sema::AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method) {
628  ObjCMethodList &FirstMethod = InstanceMethodPool[Method->getSelector()];
629  if (!FirstMethod.Method) {
630    // Haven't seen a method with this selector name yet - add it.
631    FirstMethod.Method = Method;
632    FirstMethod.Next = 0;
633  } else {
634    // We've seen a method with this name, now check the type signature(s).
635    bool match = MatchTwoMethodDeclarations(Method, FirstMethod.Method);
636
637    for (ObjCMethodList *Next = FirstMethod.Next; !match && Next;
638         Next = Next->Next)
639      match = MatchTwoMethodDeclarations(Method, Next->Method);
640
641    if (!match) {
642      // We have a new signature for an existing method - add it.
643      // This is extremely rare. Only 1% of Cocoa selectors are "overloaded".
644      struct ObjCMethodList *OMI = new ObjCMethodList(Method, FirstMethod.Next);
645      FirstMethod.Next = OMI;
646    }
647  }
648}
649
650void Sema::AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method) {
651  ObjCMethodList &FirstMethod = FactoryMethodPool[Method->getSelector()];
652  if (!FirstMethod.Method) {
653    // Haven't seen a method with this selector name yet - add it.
654    FirstMethod.Method = Method;
655    FirstMethod.Next = 0;
656  } else {
657    // We've seen a method with this name, now check the type signature(s).
658    bool match = MatchTwoMethodDeclarations(Method, FirstMethod.Method);
659
660    for (ObjCMethodList *Next = FirstMethod.Next; !match && Next;
661         Next = Next->Next)
662      match = MatchTwoMethodDeclarations(Method, Next->Method);
663
664    if (!match) {
665      // We have a new signature for an existing method - add it.
666      // This is extremely rare. Only 1% of Cocoa selectors are "overloaded".
667      struct ObjCMethodList *OMI = new ObjCMethodList(Method, FirstMethod.Next);
668      FirstMethod.Next = OMI;
669    }
670  }
671}
672
673// Note: For class/category implemenations, allMethods/allProperties is
674// always null.
675void Sema::ActOnAtEnd(SourceLocation AtEndLoc, DeclTy *classDecl,
676                      DeclTy **allMethods, unsigned allNum,
677                      DeclTy **allProperties, unsigned pNum) {
678  Decl *ClassDecl = static_cast<Decl *>(classDecl);
679
680  // FIXME: If we don't have a ClassDecl, we have an error. We should consider
681  // always passing in a decl. If the decl has an error, isInvalidDecl()
682  // should be true.
683  if (!ClassDecl)
684    return;
685
686  llvm::SmallVector<ObjCMethodDecl*, 32> insMethods;
687  llvm::SmallVector<ObjCMethodDecl*, 16> clsMethods;
688
689  llvm::DenseMap<Selector, const ObjCMethodDecl*> InsMap;
690  llvm::DenseMap<Selector, const ObjCMethodDecl*> ClsMap;
691
692  bool isInterfaceDeclKind =
693        (isa<ObjCInterfaceDecl>(ClassDecl) || isa<ObjCCategoryDecl>(ClassDecl)
694         || isa<ObjCProtocolDecl>(ClassDecl));
695  bool checkIdenticalMethods = isa<ObjCImplementationDecl>(ClassDecl);
696
697  // TODO: property declaration in category and protocols.
698  if (pNum != 0 && isa<ObjCInterfaceDecl>(ClassDecl)) {
699    ObjCPropertyDecl **properties = new ObjCPropertyDecl*[pNum];
700    memcpy(properties, allProperties, pNum*sizeof(ObjCPropertyDecl*));
701    dyn_cast<ObjCInterfaceDecl>(ClassDecl)->setPropertyDecls(properties);
702    dyn_cast<ObjCInterfaceDecl>(ClassDecl)->setNumPropertyDecl(pNum);
703  }
704
705  for (unsigned i = 0; i < allNum; i++ ) {
706    ObjCMethodDecl *Method =
707      cast_or_null<ObjCMethodDecl>(static_cast<Decl*>(allMethods[i]));
708
709    if (!Method) continue;  // Already issued a diagnostic.
710    if (Method->isInstance()) {
711      /// Check for instance method of the same name with incompatible types
712      const ObjCMethodDecl *&PrevMethod = InsMap[Method->getSelector()];
713      bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod)
714                              : false;
715      if (isInterfaceDeclKind && PrevMethod && !match
716          || checkIdenticalMethods && match) {
717          Diag(Method->getLocation(), diag::error_duplicate_method_decl,
718               Method->getSelector().getName());
719          Diag(PrevMethod->getLocation(), diag::err_previous_declaration);
720      } else {
721        insMethods.push_back(Method);
722        InsMap[Method->getSelector()] = Method;
723        /// The following allows us to typecheck messages to "id".
724        AddInstanceMethodToGlobalPool(Method);
725      }
726    }
727    else {
728      /// Check for class method of the same name with incompatible types
729      const ObjCMethodDecl *&PrevMethod = ClsMap[Method->getSelector()];
730      bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod)
731                              : false;
732      if (isInterfaceDeclKind && PrevMethod && !match
733          || checkIdenticalMethods && match) {
734        Diag(Method->getLocation(), diag::error_duplicate_method_decl,
735             Method->getSelector().getName());
736        Diag(PrevMethod->getLocation(), diag::err_previous_declaration);
737      } else {
738        clsMethods.push_back(Method);
739        ClsMap[Method->getSelector()] = Method;
740        /// The following allows us to typecheck messages to "Class".
741        AddFactoryMethodToGlobalPool(Method);
742      }
743    }
744  }
745
746  if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) {
747    I->addMethods(&insMethods[0], insMethods.size(),
748                  &clsMethods[0], clsMethods.size(), AtEndLoc);
749  } else if (ObjCProtocolDecl *P = dyn_cast<ObjCProtocolDecl>(ClassDecl)) {
750    P->addMethods(&insMethods[0], insMethods.size(),
751                  &clsMethods[0], clsMethods.size(), AtEndLoc);
752  }
753  else if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(ClassDecl)) {
754    C->addMethods(&insMethods[0], insMethods.size(),
755                  &clsMethods[0], clsMethods.size(), AtEndLoc);
756  }
757  else if (ObjCImplementationDecl *IC =
758                dyn_cast<ObjCImplementationDecl>(ClassDecl)) {
759    IC->setLocEnd(AtEndLoc);
760    if (ObjCInterfaceDecl* IDecl = getObjCInterfaceDecl(IC->getIdentifier()))
761      ImplMethodsVsClassMethods(IC, IDecl);
762  } else {
763    ObjCCategoryImplDecl* CatImplClass = cast<ObjCCategoryImplDecl>(ClassDecl);
764    CatImplClass->setLocEnd(AtEndLoc);
765    ObjCInterfaceDecl* IDecl = CatImplClass->getClassInterface();
766    // Find category interface decl and then check that all methods declared
767    // in this interface is implemented in the category @implementation.
768    if (IDecl) {
769      for (ObjCCategoryDecl *Categories = IDecl->getCategoryList();
770           Categories; Categories = Categories->getNextClassCategory()) {
771        if (Categories->getIdentifier() == CatImplClass->getIdentifier()) {
772          ImplCategoryMethodsVsIntfMethods(CatImplClass, Categories);
773          break;
774        }
775      }
776    }
777  }
778}
779
780
781/// CvtQTToAstBitMask - utility routine to produce an AST bitmask for
782/// objective-c's type qualifier from the parser version of the same info.
783static Decl::ObjCDeclQualifier
784CvtQTToAstBitMask(ObjCDeclSpec::ObjCDeclQualifier PQTVal) {
785  Decl::ObjCDeclQualifier ret = Decl::OBJC_TQ_None;
786  if (PQTVal & ObjCDeclSpec::DQ_In)
787    ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_In);
788  if (PQTVal & ObjCDeclSpec::DQ_Inout)
789    ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Inout);
790  if (PQTVal & ObjCDeclSpec::DQ_Out)
791    ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Out);
792  if (PQTVal & ObjCDeclSpec::DQ_Bycopy)
793    ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Bycopy);
794  if (PQTVal & ObjCDeclSpec::DQ_Byref)
795    ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Byref);
796  if (PQTVal & ObjCDeclSpec::DQ_Oneway)
797    ret = (Decl::ObjCDeclQualifier)(ret | Decl::OBJC_TQ_Oneway);
798
799  return ret;
800}
801
802Sema::DeclTy *Sema::ActOnMethodDeclaration(
803    SourceLocation MethodLoc, SourceLocation EndLoc,
804    tok::TokenKind MethodType, DeclTy *classDecl,
805    ObjCDeclSpec &ReturnQT, TypeTy *ReturnType,
806    Selector Sel,
807    // optional arguments. The number of types/arguments is obtained
808    // from the Sel.getNumArgs().
809    ObjCDeclSpec *ArgQT, TypeTy **ArgTypes, IdentifierInfo **ArgNames,
810    AttributeList *AttrList, tok::ObjCKeywordKind MethodDeclKind,
811    bool isVariadic) {
812  Decl *ClassDecl = static_cast<Decl*>(classDecl);
813
814  // Make sure we can establish a context for the method.
815  if (!ClassDecl) {
816    Diag(MethodLoc, diag::error_missing_method_context);
817    return 0;
818  }
819  llvm::SmallVector<ParmVarDecl*, 16> Params;
820
821  for (unsigned i = 0; i < Sel.getNumArgs(); i++) {
822    // FIXME: arg->AttrList must be stored too!
823    QualType argType;
824
825    if (ArgTypes[i])
826      argType = QualType::getFromOpaquePtr(ArgTypes[i]);
827    else
828      argType = Context.getObjCIdType();
829    ParmVarDecl* Param = ParmVarDecl::Create(Context, SourceLocation(/*FIXME*/),
830                                             ArgNames[i], argType,
831                                             VarDecl::None, 0);
832    Param->setObjCDeclQualifier(
833      CvtQTToAstBitMask(ArgQT[i].getObjCDeclQualifier()));
834    Params.push_back(Param);
835  }
836  QualType resultDeclType;
837
838  if (ReturnType)
839    resultDeclType = QualType::getFromOpaquePtr(ReturnType);
840  else // get the type for "id".
841    resultDeclType = Context.getObjCIdType();
842
843  ObjCMethodDecl* ObjCMethod =
844    ObjCMethodDecl::Create(Context, MethodLoc, EndLoc, Sel, resultDeclType,
845                           ClassDecl, AttrList,
846                           MethodType == tok::minus, isVariadic,
847                           MethodDeclKind == tok::objc_optional ?
848                           ObjCMethodDecl::Optional :
849                           ObjCMethodDecl::Required);
850
851  ObjCMethod->setMethodParams(&Params[0], Sel.getNumArgs());
852  ObjCMethod->setObjCDeclQualifier(
853    CvtQTToAstBitMask(ReturnQT.getObjCDeclQualifier()));
854  const ObjCMethodDecl *PrevMethod = 0;
855
856  // For implementations (which can be very "coarse grain"), we add the
857  // method now. This allows the AST to implement lookup methods that work
858  // incrementally (without waiting until we parse the @end). It also allows
859  // us to flag multiple declaration errors as they occur.
860  if (ObjCImplementationDecl *ImpDecl =
861        dyn_cast<ObjCImplementationDecl>(ClassDecl)) {
862    if (MethodType == tok::minus) {
863      PrevMethod = ImpDecl->getInstanceMethod(Sel);
864      ImpDecl->addInstanceMethod(ObjCMethod);
865    } else {
866      PrevMethod = ImpDecl->getClassMethod(Sel);
867      ImpDecl->addClassMethod(ObjCMethod);
868    }
869  }
870  else if (ObjCCategoryImplDecl *CatImpDecl =
871            dyn_cast<ObjCCategoryImplDecl>(ClassDecl)) {
872    if (MethodType == tok::minus) {
873      PrevMethod = CatImpDecl->getInstanceMethod(Sel);
874      CatImpDecl->addInstanceMethod(ObjCMethod);
875    } else {
876      PrevMethod = CatImpDecl->getClassMethod(Sel);
877      CatImpDecl->addClassMethod(ObjCMethod);
878    }
879  }
880  if (PrevMethod) {
881    // You can never have two method definitions with the same name.
882    Diag(ObjCMethod->getLocation(), diag::error_duplicate_method_decl,
883        ObjCMethod->getSelector().getName());
884    Diag(PrevMethod->getLocation(), diag::err_previous_declaration);
885  }
886  return ObjCMethod;
887}
888
889Sema::DeclTy *Sema::ActOnAddObjCProperties(SourceLocation AtLoc,
890  DeclTy **allProperties, unsigned NumProperties, ObjCDeclSpec &DS) {
891  ObjCPropertyDecl *PDecl = new ObjCPropertyDecl(AtLoc);
892
893  if(DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_readonly)
894    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readonly);
895
896  if(DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_getter) {
897    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_getter);
898    PDecl->setGetterName(DS.getGetterName());
899  }
900
901  if(DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_setter) {
902    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_setter);
903    PDecl->setSetterName(DS.getSetterName());
904  }
905
906  if(DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_assign)
907    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_assign);
908
909  if(DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_readwrite)
910    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readwrite);
911
912  if(DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_retain)
913    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_retain);
914
915  if(DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_copy)
916    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_copy);
917
918  if(DS.getPropertyAttributes() & ObjCDeclSpec::DQ_PR_nonatomic)
919    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_nonatomic);
920
921  PDecl->setNumPropertyDecls(NumProperties);
922  if (NumProperties != 0) {
923    ObjCIvarDecl **properties = new ObjCIvarDecl*[NumProperties];
924    memcpy(properties, allProperties, NumProperties*sizeof(ObjCIvarDecl*));
925    PDecl->setPropertyDecls(properties);
926  }
927  return PDecl;
928}
929
930