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