contrib/llvm/tools/clang/lib/Sema/SemaDeclObjC.cpp

   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 "clang/Sema/SemaInternal.h"
  15 #include "clang/Sema/Lookup.h"
  16 #include "clang/Sema/ExternalSemaSource.h"
  17 #include "clang/Sema/Scope.h"
  18 #include "clang/Sema/ScopeInfo.h"
  19 #include "clang/AST/ASTConsumer.h"
  20 #include "clang/AST/Expr.h"
  21 #include "clang/AST/ExprObjC.h"
  22 #include "clang/AST/ASTContext.h"
  23 #include "clang/AST/DeclObjC.h"
  24 #include "clang/AST/ASTMutationListener.h"
  25 #include "clang/Basic/SourceManager.h"
  26 #include "clang/Sema/DeclSpec.h"
  27 #include "clang/Lex/Preprocessor.h"
  28 #include "llvm/ADT/DenseSet.h"
  29
  30 using namespace clang;
  31
  32 /// Check whether the given method, which must be in the 'init'
  33 /// family, is a valid member of that family.
  34 ///
  35 /// \param receiverTypeIfCall - if null, check this as if declaring it;
  36 ///   if non-null, check this as if making a call to it with the given
  37 ///   receiver type
  38 ///
  39 /// \return true to indicate that there was an error and appropriate
  40 ///   actions were taken
  41 bool Sema::checkInitMethod(ObjCMethodDecl *method,
  42                            QualType receiverTypeIfCall) {
  43   if (method->isInvalidDecl()) return true;
  44
  45   // This castAs is safe: methods that don't return an object
  46   // pointer won't be inferred as inits and will reject an explicit
  47   // objc_method_family(init).
  48
  49   // We ignore protocols here.  Should we?  What about Class?
  50
  51   const ObjCObjectType *result = method->getResultType()
  52     ->castAs<ObjCObjectPointerType>()->getObjectType();
  53
  54   if (result->isObjCId()) {
  55     return false;
  56   } else if (result->isObjCClass()) {
  57     // fall through: always an error
  58   } else {
  59     ObjCInterfaceDecl *resultClass = result->getInterface();
  60     assert(resultClass && "unexpected object type!");
  61
  62     // It's okay for the result type to still be a forward declaration
  63     // if we're checking an interface declaration.
  64     if (!resultClass->hasDefinition()) {
  65       if (receiverTypeIfCall.isNull() &&
  66           !isa<ObjCImplementationDecl>(method->getDeclContext()))
  67         return false;
  68
  69     // Otherwise, we try to compare class types.
  70     } else {
  71       // If this method was declared in a protocol, we can't check
  72       // anything unless we have a receiver type that's an interface.
  73       const ObjCInterfaceDecl *receiverClass = 0;
  74       if (isa<ObjCProtocolDecl>(method->getDeclContext())) {
  75         if (receiverTypeIfCall.isNull())
  76           return false;
  77
  78         receiverClass = receiverTypeIfCall->castAs<ObjCObjectPointerType>()
  79           ->getInterfaceDecl();
  80
  81         // This can be null for calls to e.g. id<Foo>.
  82         if (!receiverClass) return false;
  83       } else {
  84         receiverClass = method->getClassInterface();
  85         assert(receiverClass && "method not associated with a class!");
  86       }
  87
  88       // If either class is a subclass of the other, it's fine.
  89       if (receiverClass->isSuperClassOf(resultClass) ||
  90           resultClass->isSuperClassOf(receiverClass))
  91         return false;
  92     }
  93   }
  94
  95   SourceLocation loc = method->getLocation();
  96
  97   // If we're in a system header, and this is not a call, just make
  98   // the method unusable.
  99   if (receiverTypeIfCall.isNull() && getSourceManager().isInSystemHeader(loc)) {
 100     method->addAttr(new (Context) UnavailableAttr(loc, Context,
 101                 "init method returns a type unrelated to its receiver type"));
 102     return true;
 103   }
 104
 105   // Otherwise, it's an error.
 106   Diag(loc, diag::err_arc_init_method_unrelated_result_type);
 107   method->setInvalidDecl();
 108   return true;
 109 }
 110
 111 void Sema::CheckObjCMethodOverride(ObjCMethodDecl *NewMethod,
 112                                    const ObjCMethodDecl *Overridden,
 113                                    bool IsImplementation) {
 114   if (Overridden->hasRelatedResultType() &&
 115       !NewMethod->hasRelatedResultType()) {
 116     // This can only happen when the method follows a naming convention that
 117     // implies a related result type, and the original (overridden) method has
 118     // a suitable return type, but the new (overriding) method does not have
 119     // a suitable return type.
 120     QualType ResultType = NewMethod->getResultType();
 121     SourceRange ResultTypeRange;
 122     if (const TypeSourceInfo *ResultTypeInfo
 123                                         = NewMethod->getResultTypeSourceInfo())
 124       ResultTypeRange = ResultTypeInfo->getTypeLoc().getSourceRange();
 125
 126     // Figure out which class this method is part of, if any.
 127     ObjCInterfaceDecl *CurrentClass
 128       = dyn_cast<ObjCInterfaceDecl>(NewMethod->getDeclContext());
 129     if (!CurrentClass) {
 130       DeclContext *DC = NewMethod->getDeclContext();
 131       if (ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(DC))
 132         CurrentClass = Cat->getClassInterface();
 133       else if (ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(DC))
 134         CurrentClass = Impl->getClassInterface();
 135       else if (ObjCCategoryImplDecl *CatImpl
 136                = dyn_cast<ObjCCategoryImplDecl>(DC))
 137         CurrentClass = CatImpl->getClassInterface();
 138     }
 139
 140     if (CurrentClass) {
 141       Diag(NewMethod->getLocation(),
 142            diag::warn_related_result_type_compatibility_class)
 143         << Context.getObjCInterfaceType(CurrentClass)
 144         << ResultType
 145         << ResultTypeRange;
 146     } else {
 147       Diag(NewMethod->getLocation(),
 148            diag::warn_related_result_type_compatibility_protocol)
 149         << ResultType
 150         << ResultTypeRange;
 151     }
 152
 153     if (ObjCMethodFamily Family = Overridden->getMethodFamily())
 154       Diag(Overridden->getLocation(),
 155            diag::note_related_result_type_overridden_family)
 156         << Family;
 157     else
 158       Diag(Overridden->getLocation(),
 159            diag::note_related_result_type_overridden);
 160   }
 161   if (getLangOpts().ObjCAutoRefCount) {
 162     if ((NewMethod->hasAttr<NSReturnsRetainedAttr>() !=
 163          Overridden->hasAttr<NSReturnsRetainedAttr>())) {
 164         Diag(NewMethod->getLocation(),
 165              diag::err_nsreturns_retained_attribute_mismatch) << 1;
 166         Diag(Overridden->getLocation(), diag::note_previous_decl)
 167         << "method";
 168     }
 169     if ((NewMethod->hasAttr<NSReturnsNotRetainedAttr>() !=
 170               Overridden->hasAttr<NSReturnsNotRetainedAttr>())) {
 171         Diag(NewMethod->getLocation(),
 172              diag::err_nsreturns_retained_attribute_mismatch) << 0;
 173         Diag(Overridden->getLocation(), diag::note_previous_decl)
 174         << "method";
 175     }
 176     ObjCMethodDecl::param_const_iterator oi = Overridden->param_begin(),
 177                                          oe = Overridden->param_end();
 178     for (ObjCMethodDecl::param_iterator
 179            ni = NewMethod->param_begin(), ne = NewMethod->param_end();
 180          ni != ne && oi != oe; ++ni, ++oi) {
 181       const ParmVarDecl *oldDecl = (*oi);
 182       ParmVarDecl *newDecl = (*ni);
 183       if (newDecl->hasAttr<NSConsumedAttr>() !=
 184           oldDecl->hasAttr<NSConsumedAttr>()) {
 185         Diag(newDecl->getLocation(),
 186              diag::err_nsconsumed_attribute_mismatch);
 187         Diag(oldDecl->getLocation(), diag::note_previous_decl)
 188           << "parameter";
 189       }
 190     }
 191   }
 192 }
 193
 194 /// \brief Check a method declaration for compatibility with the Objective-C
 195 /// ARC conventions.
 196 static bool CheckARCMethodDecl(Sema &S, ObjCMethodDecl *method) {
 197   ObjCMethodFamily family = method->getMethodFamily();
 198   switch (family) {
 199   case OMF_None:
 200   case OMF_finalize:
 201   case OMF_retain:
 202   case OMF_release:
 203   case OMF_autorelease:
 204   case OMF_retainCount:
 205   case OMF_self:
 206   case OMF_performSelector:
 207     return false;
 208
 209   case OMF_dealloc:
 210     if (!S.Context.hasSameType(method->getResultType(), S.Context.VoidTy)) {
 211       SourceRange ResultTypeRange;
 212       if (const TypeSourceInfo *ResultTypeInfo
 213           = method->getResultTypeSourceInfo())
 214         ResultTypeRange = ResultTypeInfo->getTypeLoc().getSourceRange();
 215       if (ResultTypeRange.isInvalid())
 216         S.Diag(method->getLocation(), diag::error_dealloc_bad_result_type)
 217           << method->getResultType()
 218           << FixItHint::CreateInsertion(method->getSelectorLoc(0), "(void)");
 219       else
 220         S.Diag(method->getLocation(), diag::error_dealloc_bad_result_type)
 221           << method->getResultType()
 222           << FixItHint::CreateReplacement(ResultTypeRange, "void");
 223       return true;
 224     }
 225     return false;
 226
 227   case OMF_init:
 228     // If the method doesn't obey the init rules, don't bother annotating it.
 229     if (S.checkInitMethod(method, QualType()))
 230       return true;
 231
 232     method->addAttr(new (S.Context) NSConsumesSelfAttr(SourceLocation(),
 233                                                        S.Context));
 234
 235     // Don't add a second copy of this attribute, but otherwise don't
 236     // let it be suppressed.
 237     if (method->hasAttr<NSReturnsRetainedAttr>())
 238       return false;
 239     break;
 240
 241   case OMF_alloc:
 242   case OMF_copy:
 243   case OMF_mutableCopy:
 244   case OMF_new:
 245     if (method->hasAttr<NSReturnsRetainedAttr>() ||
 246         method->hasAttr<NSReturnsNotRetainedAttr>() ||
 247         method->hasAttr<NSReturnsAutoreleasedAttr>())
 248       return false;
 249     break;
 250   }
 251
 252   method->addAttr(new (S.Context) NSReturnsRetainedAttr(SourceLocation(),
 253                                                         S.Context));
 254   return false;
 255 }
 256
 257 static void DiagnoseObjCImplementedDeprecations(Sema &S,
 258                                                 NamedDecl *ND,
 259                                                 SourceLocation ImplLoc,
 260                                                 int select) {
 261   if (ND && ND->isDeprecated()) {
 262     S.Diag(ImplLoc, diag::warn_deprecated_def) << select;
 263     if (select == 0)
 264       S.Diag(ND->getLocation(), diag::note_method_declared_at)
 265         << ND->getDeclName();
 266     else
 267       S.Diag(ND->getLocation(), diag::note_previous_decl) << "class";
 268   }
 269 }
 270
 271 /// AddAnyMethodToGlobalPool - Add any method, instance or factory to global
 272 /// pool.
 273 void Sema::AddAnyMethodToGlobalPool(Decl *D) {
 274   ObjCMethodDecl *MDecl = dyn_cast_or_null<ObjCMethodDecl>(D);
 275
 276   // If we don't have a valid method decl, simply return.
 277   if (!MDecl)
 278     return;
 279   if (MDecl->isInstanceMethod())
 280     AddInstanceMethodToGlobalPool(MDecl, true);
 281   else
 282     AddFactoryMethodToGlobalPool(MDecl, true);
 283 }
 284
 285 /// HasExplicitOwnershipAttr - returns true when pointer to ObjC pointer
 286 /// has explicit ownership attribute; false otherwise.
 287 static bool
 288 HasExplicitOwnershipAttr(Sema &S, ParmVarDecl *Param) {
 289   QualType T = Param->getType();
 290
 291   if (const PointerType *PT = T->getAs<PointerType>()) {
 292     T = PT->getPointeeType();
 293   } else if (const ReferenceType *RT = T->getAs<ReferenceType>()) {
 294     T = RT->getPointeeType();
 295   } else {
 296     return true;
 297   }
 298
 299   // If we have a lifetime qualifier, but it's local, we must have
 300   // inferred it. So, it is implicit.
 301   return !T.getLocalQualifiers().hasObjCLifetime();
 302 }
 303
 304 /// ActOnStartOfObjCMethodDef - This routine sets up parameters; invisible
 305 /// and user declared, in the method definition's AST.
 306 void Sema::ActOnStartOfObjCMethodDef(Scope *FnBodyScope, Decl *D) {
 307   assert((getCurMethodDecl() == 0) && "Methodparsing confused");
 308   ObjCMethodDecl *MDecl = dyn_cast_or_null<ObjCMethodDecl>(D);
 309
 310   // If we don't have a valid method decl, simply return.
 311   if (!MDecl)
 312     return;
 313
 314   // Allow all of Sema to see that we are entering a method definition.
 315   PushDeclContext(FnBodyScope, MDecl);
 316   PushFunctionScope();
 317
 318   // Create Decl objects for each parameter, entrring them in the scope for
 319   // binding to their use.
 320
 321   // Insert the invisible arguments, self and _cmd!
 322   MDecl->createImplicitParams(Context, MDecl->getClassInterface());
 323
 324   PushOnScopeChains(MDecl->getSelfDecl(), FnBodyScope);
 325   PushOnScopeChains(MDecl->getCmdDecl(), FnBodyScope);
 326
 327   // Introduce all of the other parameters into this scope.
 328   for (ObjCMethodDecl::param_iterator PI = MDecl->param_begin(),
 329        E = MDecl->param_end(); PI != E; ++PI) {
 330     ParmVarDecl *Param = (*PI);
 331     if (!Param->isInvalidDecl() &&
 332         RequireCompleteType(Param->getLocation(), Param->getType(),
 333                             diag::err_typecheck_decl_incomplete_type))
 334           Param->setInvalidDecl();
 335     if (!Param->isInvalidDecl() &&
 336         getLangOpts().ObjCAutoRefCount &&
 337         !HasExplicitOwnershipAttr(*this, Param))
 338       Diag(Param->getLocation(), diag::warn_arc_strong_pointer_objc_pointer) <<
 339             Param->getType();
 340
 341     if ((*PI)->getIdentifier())
 342       PushOnScopeChains(*PI, FnBodyScope);
 343   }
 344
 345   // In ARC, disallow definition of retain/release/autorelease/retainCount
 346   if (getLangOpts().ObjCAutoRefCount) {
 347     switch (MDecl->getMethodFamily()) {
 348     case OMF_retain:
 349     case OMF_retainCount:
 350     case OMF_release:
 351     case OMF_autorelease:
 352       Diag(MDecl->getLocation(), diag::err_arc_illegal_method_def)
 353         << MDecl->getSelector();
 354       break;
 355
 356     case OMF_None:
 357     case OMF_dealloc:
 358     case OMF_finalize:
 359     case OMF_alloc:
 360     case OMF_init:
 361     case OMF_mutableCopy:
 362     case OMF_copy:
 363     case OMF_new:
 364     case OMF_self:
 365     case OMF_performSelector:
 366       break;
 367     }
 368   }
 369
 370   // Warn on deprecated methods under -Wdeprecated-implementations,
 371   // and prepare for warning on missing super calls.
 372   if (ObjCInterfaceDecl *IC = MDecl->getClassInterface()) {
 373     ObjCMethodDecl *IMD =
 374       IC->lookupMethod(MDecl->getSelector(), MDecl->isInstanceMethod());
 375
 376     if (IMD)
 377       DiagnoseObjCImplementedDeprecations(*this,
 378                                           dyn_cast<NamedDecl>(IMD),
 379                                           MDecl->getLocation(), 0);
 380
 381     // If this is "dealloc" or "finalize", set some bit here.
 382     // Then in ActOnSuperMessage() (SemaExprObjC), set it back to false.
 383     // Finally, in ActOnFinishFunctionBody() (SemaDecl), warn if flag is set.
 384     // Only do this if the current class actually has a superclass.
 385     if (IC->getSuperClass()) {
 386       ObjCMethodFamily Family = MDecl->getMethodFamily();
 387       if (Family == OMF_dealloc) {
 388         if (!(getLangOpts().ObjCAutoRefCount ||
 389               getLangOpts().getGC() == LangOptions::GCOnly))
 390           getCurFunction()->ObjCShouldCallSuper = true;
 391
 392       } else if (Family == OMF_finalize) {
 393         if (Context.getLangOpts().getGC() != LangOptions::NonGC)
 394           getCurFunction()->ObjCShouldCallSuper = true;
 395
 396       } else {
 397         const ObjCMethodDecl *SuperMethod =
 398           IC->getSuperClass()->lookupMethod(MDecl->getSelector(),
 399                                             MDecl->isInstanceMethod());
 400         getCurFunction()->ObjCShouldCallSuper =
 401           (SuperMethod && SuperMethod->hasAttr<ObjCRequiresSuperAttr>());
 402       }
 403     }
 404   }
 405 }
 406
 407 namespace {
 408
 409 // Callback to only accept typo corrections that are Objective-C classes.
 410 // If an ObjCInterfaceDecl* is given to the constructor, then the validation
 411 // function will reject corrections to that class.
 412 class ObjCInterfaceValidatorCCC : public CorrectionCandidateCallback {
 413  public:
 414   ObjCInterfaceValidatorCCC() : CurrentIDecl(0) {}
 415   explicit ObjCInterfaceValidatorCCC(ObjCInterfaceDecl *IDecl)
 416       : CurrentIDecl(IDecl) {}
 417
 418   virtual bool ValidateCandidate(const TypoCorrection &candidate) {
 419     ObjCInterfaceDecl *ID = candidate.getCorrectionDeclAs<ObjCInterfaceDecl>();
 420     return ID && !declaresSameEntity(ID, CurrentIDecl);
 421   }
 422
 423  private:
 424   ObjCInterfaceDecl *CurrentIDecl;
 425 };
 426
 427 }
 428
 429 Decl *Sema::
 430 ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
 431                          IdentifierInfo *ClassName, SourceLocation ClassLoc,
 432                          IdentifierInfo *SuperName, SourceLocation SuperLoc,
 433                          Decl * const *ProtoRefs, unsigned NumProtoRefs,
 434                          const SourceLocation *ProtoLocs,
 435                          SourceLocation EndProtoLoc, AttributeList *AttrList) {
 436   assert(ClassName && "Missing class identifier");
 437
 438   // Check for another declaration kind with the same name.
 439   NamedDecl *PrevDecl = LookupSingleName(TUScope, ClassName, ClassLoc,
 440                                          LookupOrdinaryName, ForRedeclaration);
 441
 442   if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
 443     Diag(ClassLoc, diag::err_redefinition_different_kind) << ClassName;
 444     Diag(PrevDecl->getLocation(), diag::note_previous_definition);
 445   }
 446
 447   // Create a declaration to describe this @interface.
 448   ObjCInterfaceDecl* PrevIDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
 449   ObjCInterfaceDecl *IDecl
 450     = ObjCInterfaceDecl::Create(Context, CurContext, AtInterfaceLoc, ClassName,
 451                                 PrevIDecl, ClassLoc);
 452
 453   if (PrevIDecl) {
 454     // Class already seen. Was it a definition?
 455     if (ObjCInterfaceDecl *Def = PrevIDecl->getDefinition()) {
 456       Diag(AtInterfaceLoc, diag::err_duplicate_class_def)
 457         << PrevIDecl->getDeclName();
 458       Diag(Def->getLocation(), diag::note_previous_definition);
 459       IDecl->setInvalidDecl();
 460     }
 461   }
 462
 463   if (AttrList)
 464     ProcessDeclAttributeList(TUScope, IDecl, AttrList);
 465   PushOnScopeChains(IDecl, TUScope);
 466
 467   // Start the definition of this class. If we're in a redefinition case, there
 468   // may already be a definition, so we'll end up adding to it.
 469   if (!IDecl->hasDefinition())
 470     IDecl->startDefinition();
 471
 472   if (SuperName) {
 473     // Check if a different kind of symbol declared in this scope.
 474     PrevDecl = LookupSingleName(TUScope, SuperName, SuperLoc,
 475                                 LookupOrdinaryName);
 476
 477     if (!PrevDecl) {
 478       // Try to correct for a typo in the superclass name without correcting
 479       // to the class we're defining.
 480       ObjCInterfaceValidatorCCC Validator(IDecl);
 481       if (TypoCorrection Corrected = CorrectTypo(
 482           DeclarationNameInfo(SuperName, SuperLoc), LookupOrdinaryName, TUScope,
 483           NULL, Validator)) {
 484         PrevDecl = Corrected.getCorrectionDeclAs<ObjCInterfaceDecl>();
 485         Diag(SuperLoc, diag::err_undef_superclass_suggest)
 486           << SuperName << ClassName << PrevDecl->getDeclName();
 487         Diag(PrevDecl->getLocation(), diag::note_previous_decl)
 488           << PrevDecl->getDeclName();
 489       }
 490     }
 491
 492     if (declaresSameEntity(PrevDecl, IDecl)) {
 493       Diag(SuperLoc, diag::err_recursive_superclass)
 494         << SuperName << ClassName << SourceRange(AtInterfaceLoc, ClassLoc);
 495       IDecl->setEndOfDefinitionLoc(ClassLoc);
 496     } else {
 497       ObjCInterfaceDecl *SuperClassDecl =
 498                                 dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
 499
 500       // Diagnose classes that inherit from deprecated classes.
 501       if (SuperClassDecl)
 502         (void)DiagnoseUseOfDecl(SuperClassDecl, SuperLoc);
 503
 504       if (PrevDecl && SuperClassDecl == 0) {
 505         // The previous declaration was not a class decl. Check if we have a
 506         // typedef. If we do, get the underlying class type.
 507         if (const TypedefNameDecl *TDecl =
 508               dyn_cast_or_null<TypedefNameDecl>(PrevDecl)) {
 509           QualType T = TDecl->getUnderlyingType();
 510           if (T->isObjCObjectType()) {
 511             if (NamedDecl *IDecl = T->getAs<ObjCObjectType>()->getInterface())
 512               SuperClassDecl = dyn_cast<ObjCInterfaceDecl>(IDecl);
 513           }
 514         }
 515
 516         // This handles the following case:
 517         //
 518         // typedef int SuperClass;
 519         // @interface MyClass : SuperClass {} @end
 520         //
 521         if (!SuperClassDecl) {
 522           Diag(SuperLoc, diag::err_redefinition_different_kind) << SuperName;
 523           Diag(PrevDecl->getLocation(), diag::note_previous_definition);
 524         }
 525       }
 526
 527       if (!dyn_cast_or_null<TypedefNameDecl>(PrevDecl)) {
 528         if (!SuperClassDecl)
 529           Diag(SuperLoc, diag::err_undef_superclass)
 530             << SuperName << ClassName << SourceRange(AtInterfaceLoc, ClassLoc);
 531         else if (RequireCompleteType(SuperLoc,
 532                                   Context.getObjCInterfaceType(SuperClassDecl),
 533                                      diag::err_forward_superclass,
 534                                      SuperClassDecl->getDeclName(),
 535                                      ClassName,
 536                                      SourceRange(AtInterfaceLoc, ClassLoc))) {
 537           SuperClassDecl = 0;
 538         }
 539       }
 540       IDecl->setSuperClass(SuperClassDecl);
 541       IDecl->setSuperClassLoc(SuperLoc);
 542       IDecl->setEndOfDefinitionLoc(SuperLoc);
 543     }
 544   } else { // we have a root class.
 545     IDecl->setEndOfDefinitionLoc(ClassLoc);
 546   }
 547
 548   // Check then save referenced protocols.
 549   if (NumProtoRefs) {
 550     IDecl->setProtocolList((ObjCProtocolDecl*const*)ProtoRefs, NumProtoRefs,
 551                            ProtoLocs, Context);
 552     IDecl->setEndOfDefinitionLoc(EndProtoLoc);
 553   }
 554
 555   CheckObjCDeclScope(IDecl);
 556   return ActOnObjCContainerStartDefinition(IDecl);
 557 }
 558
 559 /// ActOnCompatibilityAlias - this action is called after complete parsing of
 560 /// a \@compatibility_alias declaration. It sets up the alias relationships.
 561 Decl *Sema::ActOnCompatibilityAlias(SourceLocation AtLoc,
 562                                     IdentifierInfo *AliasName,
 563                                     SourceLocation AliasLocation,
 564                                     IdentifierInfo *ClassName,
 565                                     SourceLocation ClassLocation) {
 566   // Look for previous declaration of alias name
 567   NamedDecl *ADecl = LookupSingleName(TUScope, AliasName, AliasLocation,
 568                                       LookupOrdinaryName, ForRedeclaration);
 569   if (ADecl) {
 570     if (isa<ObjCCompatibleAliasDecl>(ADecl))
 571       Diag(AliasLocation, diag::warn_previous_alias_decl);
 572     else
 573       Diag(AliasLocation, diag::err_conflicting_aliasing_type) << AliasName;
 574     Diag(ADecl->getLocation(), diag::note_previous_declaration);
 575     return 0;
 576   }
 577   // Check for class declaration
 578   NamedDecl *CDeclU = LookupSingleName(TUScope, ClassName, ClassLocation,
 579                                        LookupOrdinaryName, ForRedeclaration);
 580   if (const TypedefNameDecl *TDecl =
 581         dyn_cast_or_null<TypedefNameDecl>(CDeclU)) {
 582     QualType T = TDecl->getUnderlyingType();
 583     if (T->isObjCObjectType()) {
 584       if (NamedDecl *IDecl = T->getAs<ObjCObjectType>()->getInterface()) {
 585         ClassName = IDecl->getIdentifier();
 586         CDeclU = LookupSingleName(TUScope, ClassName, ClassLocation,
 587                                   LookupOrdinaryName, ForRedeclaration);
 588       }
 589     }
 590   }
 591   ObjCInterfaceDecl *CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(CDeclU);
 592   if (CDecl == 0) {
 593     Diag(ClassLocation, diag::warn_undef_interface) << ClassName;
 594     if (CDeclU)
 595       Diag(CDeclU->getLocation(), diag::note_previous_declaration);
 596     return 0;
 597   }
 598
 599   // Everything checked out, instantiate a new alias declaration AST.
 600   ObjCCompatibleAliasDecl *AliasDecl =
 601     ObjCCompatibleAliasDecl::Create(Context, CurContext, AtLoc, AliasName, CDecl);
 602
 603   if (!CheckObjCDeclScope(AliasDecl))
 604     PushOnScopeChains(AliasDecl, TUScope);
 605
 606   return AliasDecl;
 607 }
 608
 609 bool Sema::CheckForwardProtocolDeclarationForCircularDependency(
 610   IdentifierInfo *PName,
 611   SourceLocation &Ploc, SourceLocation PrevLoc,
 612   const ObjCList<ObjCProtocolDecl> &PList) {
 613
 614   bool res = false;
 615   for (ObjCList<ObjCProtocolDecl>::iterator I = PList.begin(),
 616        E = PList.end(); I != E; ++I) {
 617     if (ObjCProtocolDecl *PDecl = LookupProtocol((*I)->getIdentifier(),
 618                                                  Ploc)) {
 619       if (PDecl->getIdentifier() == PName) {
 620         Diag(Ploc, diag::err_protocol_has_circular_dependency);
 621         Diag(PrevLoc, diag::note_previous_definition);
 622         res = true;
 623       }
 624
 625       if (!PDecl->hasDefinition())
 626         continue;
 627
 628       if (CheckForwardProtocolDeclarationForCircularDependency(PName, Ploc,
 629             PDecl->getLocation(), PDecl->getReferencedProtocols()))
 630         res = true;
 631     }
 632   }
 633   return res;
 634 }
 635
 636 Decl *
 637 Sema::ActOnStartProtocolInterface(SourceLocation AtProtoInterfaceLoc,
 638                                   IdentifierInfo *ProtocolName,
 639                                   SourceLocation ProtocolLoc,
 640                                   Decl * const *ProtoRefs,
 641                                   unsigned NumProtoRefs,
 642                                   const SourceLocation *ProtoLocs,
 643                                   SourceLocation EndProtoLoc,
 644                                   AttributeList *AttrList) {
 645   bool err = false;
 646   // FIXME: Deal with AttrList.
 647   assert(ProtocolName && "Missing protocol identifier");
 648   ObjCProtocolDecl *PrevDecl = LookupProtocol(ProtocolName, ProtocolLoc,
 649                                               ForRedeclaration);
 650   ObjCProtocolDecl *PDecl = 0;
 651   if (ObjCProtocolDecl *Def = PrevDecl? PrevDecl->getDefinition() : 0) {
 652     // If we already have a definition, complain.
 653     Diag(ProtocolLoc, diag::warn_duplicate_protocol_def) << ProtocolName;
 654     Diag(Def->getLocation(), diag::note_previous_definition);
 655
 656     // Create a new protocol that is completely distinct from previous
 657     // declarations, and do not make this protocol available for name lookup.
 658     // That way, we'll end up completely ignoring the duplicate.
 659     // FIXME: Can we turn this into an error?
 660     PDecl = ObjCProtocolDecl::Create(Context, CurContext, ProtocolName,
 661                                      ProtocolLoc, AtProtoInterfaceLoc,
 662                                      /*PrevDecl=*/0);
 663     PDecl->startDefinition();
 664   } else {
 665     if (PrevDecl) {
 666       // Check for circular dependencies among protocol declarations. This can
 667       // only happen if this protocol was forward-declared.
 668       ObjCList<ObjCProtocolDecl> PList;
 669       PList.set((ObjCProtocolDecl *const*)ProtoRefs, NumProtoRefs, Context);
 670       err = CheckForwardProtocolDeclarationForCircularDependency(
 671               ProtocolName, ProtocolLoc, PrevDecl->getLocation(), PList);
 672     }
 673
 674     // Create the new declaration.
 675     PDecl = ObjCProtocolDecl::Create(Context, CurContext, ProtocolName,
 676                                      ProtocolLoc, AtProtoInterfaceLoc,
 677                                      /*PrevDecl=*/PrevDecl);
 678
 679     PushOnScopeChains(PDecl, TUScope);
 680     PDecl->startDefinition();
 681   }
 682
 683   if (AttrList)
 684     ProcessDeclAttributeList(TUScope, PDecl, AttrList);
 685
 686   // Merge attributes from previous declarations.
 687   if (PrevDecl)
 688     mergeDeclAttributes(PDecl, PrevDecl);
 689
 690   if (!err && NumProtoRefs ) {
 691     /// Check then save referenced protocols.
 692     PDecl->setProtocolList((ObjCProtocolDecl*const*)ProtoRefs, NumProtoRefs,
 693                            ProtoLocs, Context);
 694   }
 695
 696   CheckObjCDeclScope(PDecl);
 697   return ActOnObjCContainerStartDefinition(PDecl);
 698 }
 699
 700 /// FindProtocolDeclaration - This routine looks up protocols and
 701 /// issues an error if they are not declared. It returns list of
 702 /// protocol declarations in its 'Protocols' argument.
 703 void
 704 Sema::FindProtocolDeclaration(bool WarnOnDeclarations,
 705                               const IdentifierLocPair *ProtocolId,
 706                               unsigned NumProtocols,
 707                               SmallVectorImpl<Decl *> &Protocols) {
 708   for (unsigned i = 0; i != NumProtocols; ++i) {
 709     ObjCProtocolDecl *PDecl = LookupProtocol(ProtocolId[i].first,
 710                                              ProtocolId[i].second);
 711     if (!PDecl) {
 712       DeclFilterCCC<ObjCProtocolDecl> Validator;
 713       TypoCorrection Corrected = CorrectTypo(
 714           DeclarationNameInfo(ProtocolId[i].first, ProtocolId[i].second),
 715           LookupObjCProtocolName, TUScope, NULL, Validator);
 716       if ((PDecl = Corrected.getCorrectionDeclAs<ObjCProtocolDecl>())) {
 717         Diag(ProtocolId[i].second, diag::err_undeclared_protocol_suggest)
 718           << ProtocolId[i].first << Corrected.getCorrection();
 719         Diag(PDecl->getLocation(), diag::note_previous_decl)
 720           << PDecl->getDeclName();
 721       }
 722     }
 723
 724     if (!PDecl) {
 725       Diag(ProtocolId[i].second, diag::err_undeclared_protocol)
 726         << ProtocolId[i].first;
 727       continue;
 728     }
 729
 730     (void)DiagnoseUseOfDecl(PDecl, ProtocolId[i].second);
 731
 732     // If this is a forward declaration and we are supposed to warn in this
 733     // case, do it.
 734     if (WarnOnDeclarations && !PDecl->hasDefinition())
 735       Diag(ProtocolId[i].second, diag::warn_undef_protocolref)
 736         << ProtocolId[i].first;
 737     Protocols.push_back(PDecl);
 738   }
 739 }
 740
 741 /// DiagnoseClassExtensionDupMethods - Check for duplicate declaration of
 742 /// a class method in its extension.
 743 ///
 744 void Sema::DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT,
 745                                             ObjCInterfaceDecl *ID) {
 746   if (!ID)
 747     return;  // Possibly due to previous error
 748
 749   llvm::DenseMap<Selector, const ObjCMethodDecl*> MethodMap;
 750   for (ObjCInterfaceDecl::method_iterator i = ID->meth_begin(),
 751        e =  ID->meth_end(); i != e; ++i) {
 752     ObjCMethodDecl *MD = *i;
 753     MethodMap[MD->getSelector()] = MD;
 754   }
 755
 756   if (MethodMap.empty())
 757     return;
 758   for (ObjCCategoryDecl::method_iterator i = CAT->meth_begin(),
 759        e =  CAT->meth_end(); i != e; ++i) {
 760     ObjCMethodDecl *Method = *i;
 761     const ObjCMethodDecl *&PrevMethod = MethodMap[Method->getSelector()];
 762     if (PrevMethod && !MatchTwoMethodDeclarations(Method, PrevMethod)) {
 763       Diag(Method->getLocation(), diag::err_duplicate_method_decl)
 764             << Method->getDeclName();
 765       Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
 766     }
 767   }
 768 }
 769
 770 /// ActOnForwardProtocolDeclaration - Handle \@protocol foo;
 771 Sema::DeclGroupPtrTy
 772 Sema::ActOnForwardProtocolDeclaration(SourceLocation AtProtocolLoc,
 773                                       const IdentifierLocPair *IdentList,
 774                                       unsigned NumElts,
 775                                       AttributeList *attrList) {
 776   SmallVector<Decl *, 8> DeclsInGroup;
 777   for (unsigned i = 0; i != NumElts; ++i) {
 778     IdentifierInfo *Ident = IdentList[i].first;
 779     ObjCProtocolDecl *PrevDecl = LookupProtocol(Ident, IdentList[i].second,
 780                                                 ForRedeclaration);
 781     ObjCProtocolDecl *PDecl
 782       = ObjCProtocolDecl::Create(Context, CurContext, Ident,
 783                                  IdentList[i].second, AtProtocolLoc,
 784                                  PrevDecl);
 785
 786     PushOnScopeChains(PDecl, TUScope);
 787     CheckObjCDeclScope(PDecl);
 788
 789     if (attrList)
 790       ProcessDeclAttributeList(TUScope, PDecl, attrList);
 791
 792     if (PrevDecl)
 793       mergeDeclAttributes(PDecl, PrevDecl);
 794
 795     DeclsInGroup.push_back(PDecl);
 796   }
 797
 798   return BuildDeclaratorGroup(DeclsInGroup.data(), DeclsInGroup.size(), false);
 799 }
 800
 801 Decl *Sema::
 802 ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc,
 803                             IdentifierInfo *ClassName, SourceLocation ClassLoc,
 804                             IdentifierInfo *CategoryName,
 805                             SourceLocation CategoryLoc,
 806                             Decl * const *ProtoRefs,
 807                             unsigned NumProtoRefs,
 808                             const SourceLocation *ProtoLocs,
 809                             SourceLocation EndProtoLoc) {
 810   ObjCCategoryDecl *CDecl;
 811   ObjCInterfaceDecl *IDecl = getObjCInterfaceDecl(ClassName, ClassLoc, true);
 812
 813   /// Check that class of this category is already completely declared.
 814
 815   if (!IDecl
 816       || RequireCompleteType(ClassLoc, Context.getObjCInterfaceType(IDecl),
 817                              diag::err_category_forward_interface,
 818                              CategoryName == 0)) {
 819     // Create an invalid ObjCCategoryDecl to serve as context for
 820     // the enclosing method declarations.  We mark the decl invalid
 821     // to make it clear that this isn't a valid AST.
 822     CDecl = ObjCCategoryDecl::Create(Context, CurContext, AtInterfaceLoc,
 823                                      ClassLoc, CategoryLoc, CategoryName,IDecl);
 824     CDecl->setInvalidDecl();
 825     CurContext->addDecl(CDecl);
 826
 827     if (!IDecl)
 828       Diag(ClassLoc, diag::err_undef_interface) << ClassName;
 829     return ActOnObjCContainerStartDefinition(CDecl);
 830   }
 831
 832   if (!CategoryName && IDecl->getImplementation()) {
 833     Diag(ClassLoc, diag::err_class_extension_after_impl) << ClassName;
 834     Diag(IDecl->getImplementation()->getLocation(),
 835           diag::note_implementation_declared);
 836   }
 837
 838   if (CategoryName) {
 839     /// Check for duplicate interface declaration for this category
 840     ObjCCategoryDecl *CDeclChain;
 841     for (CDeclChain = IDecl->getCategoryList(); CDeclChain;
 842          CDeclChain = CDeclChain->getNextClassCategory()) {
 843       if (CDeclChain->getIdentifier() == CategoryName) {
 844         // Class extensions can be declared multiple times.
 845         Diag(CategoryLoc, diag::warn_dup_category_def)
 846           << ClassName << CategoryName;
 847         Diag(CDeclChain->getLocation(), diag::note_previous_definition);
 848         break;
 849       }
 850     }
 851   }
 852
 853   CDecl = ObjCCategoryDecl::Create(Context, CurContext, AtInterfaceLoc,
 854                                    ClassLoc, CategoryLoc, CategoryName, IDecl);
 855   // FIXME: PushOnScopeChains?
 856   CurContext->addDecl(CDecl);
 857
 858   if (NumProtoRefs) {
 859     CDecl->setProtocolList((ObjCProtocolDecl*const*)ProtoRefs, NumProtoRefs,
 860                            ProtoLocs, Context);
 861     // Protocols in the class extension belong to the class.
 862     if (CDecl->IsClassExtension())
 863      IDecl->mergeClassExtensionProtocolList((ObjCProtocolDecl*const*)ProtoRefs,
 864                                             NumProtoRefs, Context);
 865   }
 866
 867   CheckObjCDeclScope(CDecl);
 868   return ActOnObjCContainerStartDefinition(CDecl);
 869 }
 870
 871 /// ActOnStartCategoryImplementation - Perform semantic checks on the
 872 /// category implementation declaration and build an ObjCCategoryImplDecl
 873 /// object.
 874 Decl *Sema::ActOnStartCategoryImplementation(
 875                       SourceLocation AtCatImplLoc,
 876                       IdentifierInfo *ClassName, SourceLocation ClassLoc,
 877                       IdentifierInfo *CatName, SourceLocation CatLoc) {
 878   ObjCInterfaceDecl *IDecl = getObjCInterfaceDecl(ClassName, ClassLoc, true);
 879   ObjCCategoryDecl *CatIDecl = 0;
 880   if (IDecl && IDecl->hasDefinition()) {
 881     CatIDecl = IDecl->FindCategoryDeclaration(CatName);
 882     if (!CatIDecl) {
 883       // Category @implementation with no corresponding @interface.
 884       // Create and install one.
 885       CatIDecl = ObjCCategoryDecl::Create(Context, CurContext, AtCatImplLoc,
 886                                           ClassLoc, CatLoc,
 887                                           CatName, IDecl);
 888       CatIDecl->setImplicit();
 889     }
 890   }
 891
 892   ObjCCategoryImplDecl *CDecl =
 893     ObjCCategoryImplDecl::Create(Context, CurContext, CatName, IDecl,
 894                                  ClassLoc, AtCatImplLoc, CatLoc);
 895   /// Check that class of this category is already completely declared.
 896   if (!IDecl) {
 897     Diag(ClassLoc, diag::err_undef_interface) << ClassName;
 898     CDecl->setInvalidDecl();
 899   } else if (RequireCompleteType(ClassLoc, Context.getObjCInterfaceType(IDecl),
 900                                  diag::err_undef_interface)) {
 901     CDecl->setInvalidDecl();
 902   }
 903
 904   // FIXME: PushOnScopeChains?
 905   CurContext->addDecl(CDecl);
 906
 907   // If the interface is deprecated/unavailable, warn/error about it.
 908   if (IDecl)
 909     DiagnoseUseOfDecl(IDecl, ClassLoc);
 910
 911   /// Check that CatName, category name, is not used in another implementation.
 912   if (CatIDecl) {
 913     if (CatIDecl->getImplementation()) {
 914       Diag(ClassLoc, diag::err_dup_implementation_category) << ClassName
 915         << CatName;
 916       Diag(CatIDecl->getImplementation()->getLocation(),
 917            diag::note_previous_definition);
 918     } else {
 919       CatIDecl->setImplementation(CDecl);
 920       // Warn on implementating category of deprecated class under
 921       // -Wdeprecated-implementations flag.
 922       DiagnoseObjCImplementedDeprecations(*this,
 923                                           dyn_cast<NamedDecl>(IDecl),
 924                                           CDecl->getLocation(), 2);
 925     }
 926   }
 927
 928   CheckObjCDeclScope(CDecl);
 929   return ActOnObjCContainerStartDefinition(CDecl);
 930 }
 931
 932 Decl *Sema::ActOnStartClassImplementation(
 933                       SourceLocation AtClassImplLoc,
 934                       IdentifierInfo *ClassName, SourceLocation ClassLoc,
 935                       IdentifierInfo *SuperClassname,
 936                       SourceLocation SuperClassLoc) {
 937   ObjCInterfaceDecl* IDecl = 0;
 938   // Check for another declaration kind with the same name.
 939   NamedDecl *PrevDecl
 940     = LookupSingleName(TUScope, ClassName, ClassLoc, LookupOrdinaryName,
 941                        ForRedeclaration);
 942   if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
 943     Diag(ClassLoc, diag::err_redefinition_different_kind) << ClassName;
 944     Diag(PrevDecl->getLocation(), diag::note_previous_definition);
 945   } else if ((IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl))) {
 946     RequireCompleteType(ClassLoc, Context.getObjCInterfaceType(IDecl),
 947                         diag::warn_undef_interface);
 948   } else {
 949     // We did not find anything with the name ClassName; try to correct for
 950     // typos in the class name.
 951     ObjCInterfaceValidatorCCC Validator;
 952     if (TypoCorrection Corrected = CorrectTypo(
 953         DeclarationNameInfo(ClassName, ClassLoc), LookupOrdinaryName, TUScope,
 954         NULL, Validator)) {
 955       // Suggest the (potentially) correct interface name. However, put the
 956       // fix-it hint itself in a separate note, since changing the name in
 957       // the warning would make the fix-it change semantics.However, don't
 958       // provide a code-modification hint or use the typo name for recovery,
 959       // because this is just a warning. The program may actually be correct.
 960       IDecl = Corrected.getCorrectionDeclAs<ObjCInterfaceDecl>();
 961       DeclarationName CorrectedName = Corrected.getCorrection();
 962       Diag(ClassLoc, diag::warn_undef_interface_suggest)
 963         << ClassName << CorrectedName;
 964       Diag(IDecl->getLocation(), diag::note_previous_decl) << CorrectedName
 965         << FixItHint::CreateReplacement(ClassLoc, CorrectedName.getAsString());
 966       IDecl = 0;
 967     } else {
 968       Diag(ClassLoc, diag::warn_undef_interface) << ClassName;
 969     }
 970   }
 971
 972   // Check that super class name is valid class name
 973   ObjCInterfaceDecl* SDecl = 0;
 974   if (SuperClassname) {
 975     // Check if a different kind of symbol declared in this scope.
 976     PrevDecl = LookupSingleName(TUScope, SuperClassname, SuperClassLoc,
 977                                 LookupOrdinaryName);
 978     if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
 979       Diag(SuperClassLoc, diag::err_redefinition_different_kind)
 980         << SuperClassname;
 981       Diag(PrevDecl->getLocation(), diag::note_previous_definition);
 982     } else {
 983       SDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
 984       if (SDecl && !SDecl->hasDefinition())
 985         SDecl = 0;
 986       if (!SDecl)
 987         Diag(SuperClassLoc, diag::err_undef_superclass)
 988           << SuperClassname << ClassName;
 989       else if (IDecl && !declaresSameEntity(IDecl->getSuperClass(), SDecl)) {
 990         // This implementation and its interface do not have the same
 991         // super class.
 992         Diag(SuperClassLoc, diag::err_conflicting_super_class)
 993           << SDecl->getDeclName();
 994         Diag(SDecl->getLocation(), diag::note_previous_definition);
 995       }
 996     }
 997   }
 998
 999   if (!IDecl) {
1000     // Legacy case of @implementation with no corresponding @interface.
1001     // Build, chain & install the interface decl into the identifier.
1002
1003     // FIXME: Do we support attributes on the @implementation? If so we should
1004     // copy them over.
1005     IDecl = ObjCInterfaceDecl::Create(Context, CurContext, AtClassImplLoc,
1006                                       ClassName, /*PrevDecl=*/0, ClassLoc,
1007                                       true);
1008     IDecl->startDefinition();
1009     if (SDecl) {
1010       IDecl->setSuperClass(SDecl);
1011       IDecl->setSuperClassLoc(SuperClassLoc);
1012       IDecl->setEndOfDefinitionLoc(SuperClassLoc);
1013     } else {
1014       IDecl->setEndOfDefinitionLoc(ClassLoc);
1015     }
1016
1017     PushOnScopeChains(IDecl, TUScope);
1018   } else {
1019     // Mark the interface as being completed, even if it was just as
1020     //   @class ....;
1021     // declaration; the user cannot reopen it.
1022     if (!IDecl->hasDefinition())
1023       IDecl->startDefinition();
1024   }
1025
1026   ObjCImplementationDecl* IMPDecl =
1027     ObjCImplementationDecl::Create(Context, CurContext, IDecl, SDecl,
1028                                    ClassLoc, AtClassImplLoc);
1029
1030   if (CheckObjCDeclScope(IMPDecl))
1031     return ActOnObjCContainerStartDefinition(IMPDecl);
1032
1033   // Check that there is no duplicate implementation of this class.
1034   if (IDecl->getImplementation()) {
1035     // FIXME: Don't leak everything!
1036     Diag(ClassLoc, diag::err_dup_implementation_class) << ClassName;
1037     Diag(IDecl->getImplementation()->getLocation(),
1038          diag::note_previous_definition);
1039   } else { // add it to the list.
1040     IDecl->setImplementation(IMPDecl);
1041     PushOnScopeChains(IMPDecl, TUScope);
1042     // Warn on implementating deprecated class under
1043     // -Wdeprecated-implementations flag.
1044     DiagnoseObjCImplementedDeprecations(*this,
1045                                         dyn_cast<NamedDecl>(IDecl),
1046                                         IMPDecl->getLocation(), 1);
1047   }
1048   return ActOnObjCContainerStartDefinition(IMPDecl);
1049 }
1050
1051 Sema::DeclGroupPtrTy
1052 Sema::ActOnFinishObjCImplementation(Decl *ObjCImpDecl, ArrayRef<Decl *> Decls) {
1053   SmallVector<Decl *, 64> DeclsInGroup;
1054   DeclsInGroup.reserve(Decls.size() + 1);
1055
1056   for (unsigned i = 0, e = Decls.size(); i != e; ++i) {
1057     Decl *Dcl = Decls[i];
1058     if (!Dcl)
1059       continue;
1060     if (Dcl->getDeclContext()->isFileContext())
1061       Dcl->setTopLevelDeclInObjCContainer();
1062     DeclsInGroup.push_back(Dcl);
1063   }
1064
1065   DeclsInGroup.push_back(ObjCImpDecl);
1066
1067   return BuildDeclaratorGroup(DeclsInGroup.data(), DeclsInGroup.size(), false);
1068 }
1069
1070 void Sema::CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
1071                                     ObjCIvarDecl **ivars, unsigned numIvars,
1072                                     SourceLocation RBrace) {
1073   assert(ImpDecl && "missing implementation decl");
1074   ObjCInterfaceDecl* IDecl = ImpDecl->getClassInterface();
1075   if (!IDecl)
1076     return;
1077   /// Check case of non-existing \@interface decl.
1078   /// (legacy objective-c \@implementation decl without an \@interface decl).
1079   /// Add implementations's ivar to the synthesize class's ivar list.
1080   if (IDecl->isImplicitInterfaceDecl()) {
1081     IDecl->setEndOfDefinitionLoc(RBrace);
1082     // Add ivar's to class's DeclContext.
1083     for (unsigned i = 0, e = numIvars; i != e; ++i) {
1084       ivars[i]->setLexicalDeclContext(ImpDecl);
1085       IDecl->makeDeclVisibleInContext(ivars[i]);
1086       ImpDecl->addDecl(ivars[i]);
1087     }
1088
1089     return;
1090   }
1091   // If implementation has empty ivar list, just return.
1092   if (numIvars == 0)
1093     return;
1094
1095   assert(ivars && "missing @implementation ivars");
1096   if (LangOpts.ObjCRuntime.isNonFragile()) {
1097     if (ImpDecl->getSuperClass())
1098       Diag(ImpDecl->getLocation(), diag::warn_on_superclass_use);
1099     for (unsigned i = 0; i < numIvars; i++) {
1100       ObjCIvarDecl* ImplIvar = ivars[i];
1101       if (const ObjCIvarDecl *ClsIvar =
1102             IDecl->getIvarDecl(ImplIvar->getIdentifier())) {
1103         Diag(ImplIvar->getLocation(), diag::err_duplicate_ivar_declaration);
1104         Diag(ClsIvar->getLocation(), diag::note_previous_definition);
1105         continue;
1106       }
1107       // Instance ivar to Implementation's DeclContext.
1108       ImplIvar->setLexicalDeclContext(ImpDecl);
1109       IDecl->makeDeclVisibleInContext(ImplIvar);
1110       ImpDecl->addDecl(ImplIvar);
1111     }
1112     return;
1113   }
1114   // Check interface's Ivar list against those in the implementation.
1115   // names and types must match.
1116   //
1117   unsigned j = 0;
1118   ObjCInterfaceDecl::ivar_iterator
1119     IVI = IDecl->ivar_begin(), IVE = IDecl->ivar_end();
1120   for (; numIvars > 0 && IVI != IVE; ++IVI) {
1121     ObjCIvarDecl* ImplIvar = ivars[j++];
1122     ObjCIvarDecl* ClsIvar = *IVI;
1123     assert (ImplIvar && "missing implementation ivar");
1124     assert (ClsIvar && "missing class ivar");
1125
1126     // First, make sure the types match.
1127     if (!Context.hasSameType(ImplIvar->getType(), ClsIvar->getType())) {
1128       Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_type)
1129         << ImplIvar->getIdentifier()
1130         << ImplIvar->getType() << ClsIvar->getType();
1131       Diag(ClsIvar->getLocation(), diag::note_previous_definition);
1132     } else if (ImplIvar->isBitField() && ClsIvar->isBitField() &&
1133                ImplIvar->getBitWidthValue(Context) !=
1134                ClsIvar->getBitWidthValue(Context)) {
1135       Diag(ImplIvar->getBitWidth()->getLocStart(),
1136            diag::err_conflicting_ivar_bitwidth) << ImplIvar->getIdentifier();
1137       Diag(ClsIvar->getBitWidth()->getLocStart(),
1138            diag::note_previous_definition);
1139     }
1140     // Make sure the names are identical.
1141     if (ImplIvar->getIdentifier() != ClsIvar->getIdentifier()) {
1142       Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_name)
1143         << ImplIvar->getIdentifier() << ClsIvar->getIdentifier();
1144       Diag(ClsIvar->getLocation(), diag::note_previous_definition);
1145     }
1146     --numIvars;
1147   }
1148
1149   if (numIvars > 0)
1150     Diag(ivars[j]->getLocation(), diag::err_inconsistant_ivar_count);
1151   else if (IVI != IVE)
1152     Diag(IVI->getLocation(), diag::err_inconsistant_ivar_count);
1153 }
1154
1155 void Sema::WarnUndefinedMethod(SourceLocation ImpLoc, ObjCMethodDecl *method,
1156                                bool &IncompleteImpl, unsigned DiagID) {
1157   // No point warning no definition of method which is 'unavailable'.
1158   if (method->hasAttr<UnavailableAttr>())
1159     return;
1160   if (!IncompleteImpl) {
1161     Diag(ImpLoc, diag::warn_incomplete_impl);
1162     IncompleteImpl = true;
1163   }
1164   if (DiagID == diag::warn_unimplemented_protocol_method)
1165     Diag(ImpLoc, DiagID) << method->getDeclName();
1166   else
1167     Diag(method->getLocation(), DiagID) << method->getDeclName();
1168 }
1169
1170 /// Determines if type B can be substituted for type A.  Returns true if we can
1171 /// guarantee that anything that the user will do to an object of type A can
1172 /// also be done to an object of type B.  This is trivially true if the two
1173 /// types are the same, or if B is a subclass of A.  It becomes more complex
1174 /// in cases where protocols are involved.
1175 ///
1176 /// Object types in Objective-C describe the minimum requirements for an
1177 /// object, rather than providing a complete description of a type.  For
1178 /// example, if A is a subclass of B, then B* may refer to an instance of A.
1179 /// The principle of substitutability means that we may use an instance of A
1180 /// anywhere that we may use an instance of B - it will implement all of the
1181 /// ivars of B and all of the methods of B.
1182 ///
1183 /// This substitutability is important when type checking methods, because
1184 /// the implementation may have stricter type definitions than the interface.
1185 /// The interface specifies minimum requirements, but the implementation may
1186 /// have more accurate ones.  For example, a method may privately accept
1187 /// instances of B, but only publish that it accepts instances of A.  Any
1188 /// object passed to it will be type checked against B, and so will implicitly
1189 /// by a valid A*.  Similarly, a method may return a subclass of the class that
1190 /// it is declared as returning.
1191 ///
1192 /// This is most important when considering subclassing.  A method in a
1193 /// subclass must accept any object as an argument that its superclass's
1194 /// implementation accepts.  It may, however, accept a more general type
1195 /// without breaking substitutability (i.e. you can still use the subclass
1196 /// anywhere that you can use the superclass, but not vice versa).  The
1197 /// converse requirement applies to return types: the return type for a
1198 /// subclass method must be a valid object of the kind that the superclass
1199 /// advertises, but it may be specified more accurately.  This avoids the need
1200 /// for explicit down-casting by callers.
1201 ///
1202 /// Note: This is a stricter requirement than for assignment.
1203 static bool isObjCTypeSubstitutable(ASTContext &Context,
1204                                     const ObjCObjectPointerType *A,
1205                                     const ObjCObjectPointerType *B,
1206                                     bool rejectId) {
1207   // Reject a protocol-unqualified id.
1208   if (rejectId && B->isObjCIdType()) return false;
1209
1210   // If B is a qualified id, then A must also be a qualified id and it must
1211   // implement all of the protocols in B.  It may not be a qualified class.
1212   // For example, MyClass<A> can be assigned to id<A>, but MyClass<A> is a
1213   // stricter definition so it is not substitutable for id<A>.
1214   if (B->isObjCQualifiedIdType()) {
1215     return A->isObjCQualifiedIdType() &&
1216            Context.ObjCQualifiedIdTypesAreCompatible(QualType(A, 0),
1217                                                      QualType(B,0),
1218                                                      false);
1219   }
1220
1221   /*
1222   // id is a special type that bypasses type checking completely.  We want a
1223   // warning when it is used in one place but not another.
1224   if (C.isObjCIdType(A) || C.isObjCIdType(B)) return false;
1225
1226
1227   // If B is a qualified id, then A must also be a qualified id (which it isn't
1228   // if we've got this far)
1229   if (B->isObjCQualifiedIdType()) return false;
1230   */
1231
1232   // Now we know that A and B are (potentially-qualified) class types.  The
1233   // normal rules for assignment apply.
1234   return Context.canAssignObjCInterfaces(A, B);
1235 }
1236
1237 static SourceRange getTypeRange(TypeSourceInfo *TSI) {
1238   return (TSI ? TSI->getTypeLoc().getSourceRange() : SourceRange());
1239 }
1240
1241 static bool CheckMethodOverrideReturn(Sema &S,
1242                                       ObjCMethodDecl *MethodImpl,
1243                                       ObjCMethodDecl *MethodDecl,
1244                                       bool IsProtocolMethodDecl,
1245                                       bool IsOverridingMode,
1246                                       bool Warn) {
1247   if (IsProtocolMethodDecl &&
1248       (MethodDecl->getObjCDeclQualifier() !=
1249        MethodImpl->getObjCDeclQualifier())) {
1250     if (Warn) {
1251         S.Diag(MethodImpl->getLocation(),
1252                (IsOverridingMode ?
1253                  diag::warn_conflicting_overriding_ret_type_modifiers
1254                  : diag::warn_conflicting_ret_type_modifiers))
1255           << MethodImpl->getDeclName()
1256           << getTypeRange(MethodImpl->getResultTypeSourceInfo());
1257         S.Diag(MethodDecl->getLocation(), diag::note_previous_declaration)
1258           << getTypeRange(MethodDecl->getResultTypeSourceInfo());
1259     }
1260     else
1261       return false;
1262   }
1263
1264   if (S.Context.hasSameUnqualifiedType(MethodImpl->getResultType(),
1265                                        MethodDecl->getResultType()))
1266     return true;
1267   if (!Warn)
1268     return false;
1269
1270   unsigned DiagID =
1271     IsOverridingMode ? diag::warn_conflicting_overriding_ret_types
1272                      : diag::warn_conflicting_ret_types;
1273
1274   // Mismatches between ObjC pointers go into a different warning
1275   // category, and sometimes they're even completely whitelisted.
1276   if (const ObjCObjectPointerType *ImplPtrTy =
1277         MethodImpl->getResultType()->getAs<ObjCObjectPointerType>()) {
1278     if (const ObjCObjectPointerType *IfacePtrTy =
1279           MethodDecl->getResultType()->getAs<ObjCObjectPointerType>()) {
1280       // Allow non-matching return types as long as they don't violate
1281       // the principle of substitutability.  Specifically, we permit
1282       // return types that are subclasses of the declared return type,
1283       // or that are more-qualified versions of the declared type.
1284       if (isObjCTypeSubstitutable(S.Context, IfacePtrTy, ImplPtrTy, false))
1285         return false;
1286
1287       DiagID =
1288         IsOverridingMode ? diag::warn_non_covariant_overriding_ret_types
1289                           : diag::warn_non_covariant_ret_types;
1290     }
1291   }
1292
1293   S.Diag(MethodImpl->getLocation(), DiagID)
1294     << MethodImpl->getDeclName()
1295     << MethodDecl->getResultType()
1296     << MethodImpl->getResultType()
1297     << getTypeRange(MethodImpl->getResultTypeSourceInfo());
1298   S.Diag(MethodDecl->getLocation(),
1299          IsOverridingMode ? diag::note_previous_declaration
1300                           : diag::note_previous_definition)
1301     << getTypeRange(MethodDecl->getResultTypeSourceInfo());
1302   return false;
1303 }
1304
1305 static bool CheckMethodOverrideParam(Sema &S,
1306                                      ObjCMethodDecl *MethodImpl,
1307                                      ObjCMethodDecl *MethodDecl,
1308                                      ParmVarDecl *ImplVar,
1309                                      ParmVarDecl *IfaceVar,
1310                                      bool IsProtocolMethodDecl,
1311                                      bool IsOverridingMode,
1312                                      bool Warn) {
1313   if (IsProtocolMethodDecl &&
1314       (ImplVar->getObjCDeclQualifier() !=
1315        IfaceVar->getObjCDeclQualifier())) {
1316     if (Warn) {
1317       if (IsOverridingMode)
1318         S.Diag(ImplVar->getLocation(),
1319                diag::warn_conflicting_overriding_param_modifiers)
1320             << getTypeRange(ImplVar->getTypeSourceInfo())
1321             << MethodImpl->getDeclName();
1322       else S.Diag(ImplVar->getLocation(),
1323              diag::warn_conflicting_param_modifiers)
1324           << getTypeRange(ImplVar->getTypeSourceInfo())
1325           << MethodImpl->getDeclName();
1326       S.Diag(IfaceVar->getLocation(), diag::note_previous_declaration)
1327           << getTypeRange(IfaceVar->getTypeSourceInfo());
1328     }
1329     else
1330       return false;
1331   }
1332
1333   QualType ImplTy = ImplVar->getType();
1334   QualType IfaceTy = IfaceVar->getType();
1335
1336   if (S.Context.hasSameUnqualifiedType(ImplTy, IfaceTy))
1337     return true;
1338
1339   if (!Warn)
1340     return false;
1341   unsigned DiagID =
1342     IsOverridingMode ? diag::warn_conflicting_overriding_param_types
1343                      : diag::warn_conflicting_param_types;
1344
1345   // Mismatches between ObjC pointers go into a different warning
1346   // category, and sometimes they're even completely whitelisted.
1347   if (const ObjCObjectPointerType *ImplPtrTy =
1348         ImplTy->getAs<ObjCObjectPointerType>()) {
1349     if (const ObjCObjectPointerType *IfacePtrTy =
1350           IfaceTy->getAs<ObjCObjectPointerType>()) {
1351       // Allow non-matching argument types as long as they don't
1352       // violate the principle of substitutability.  Specifically, the
1353       // implementation must accept any objects that the superclass
1354       // accepts, however it may also accept others.
1355       if (isObjCTypeSubstitutable(S.Context, ImplPtrTy, IfacePtrTy, true))
1356         return false;
1357
1358       DiagID =
1359       IsOverridingMode ? diag::warn_non_contravariant_overriding_param_types
1360                        :  diag::warn_non_contravariant_param_types;
1361     }
1362   }
1363
1364   S.Diag(ImplVar->getLocation(), DiagID)
1365     << getTypeRange(ImplVar->getTypeSourceInfo())
1366     << MethodImpl->getDeclName() << IfaceTy << ImplTy;
1367   S.Diag(IfaceVar->getLocation(),
1368          (IsOverridingMode ? diag::note_previous_declaration
1369                         : diag::note_previous_definition))
1370     << getTypeRange(IfaceVar->getTypeSourceInfo());
1371   return false;
1372 }
1373
1374 /// In ARC, check whether the conventional meanings of the two methods
1375 /// match.  If they don't, it's a hard error.
1376 static bool checkMethodFamilyMismatch(Sema &S, ObjCMethodDecl *impl,
1377                                       ObjCMethodDecl *decl) {
1378   ObjCMethodFamily implFamily = impl->getMethodFamily();
1379   ObjCMethodFamily declFamily = decl->getMethodFamily();
1380   if (implFamily == declFamily) return false;
1381
1382   // Since conventions are sorted by selector, the only possibility is
1383   // that the types differ enough to cause one selector or the other
1384   // to fall out of the family.
1385   assert(implFamily == OMF_None || declFamily == OMF_None);
1386
1387   // No further diagnostics required on invalid declarations.
1388   if (impl->isInvalidDecl() || decl->isInvalidDecl()) return true;
1389
1390   const ObjCMethodDecl *unmatched = impl;
1391   ObjCMethodFamily family = declFamily;
1392   unsigned errorID = diag::err_arc_lost_method_convention;
1393   unsigned noteID = diag::note_arc_lost_method_convention;
1394   if (declFamily == OMF_None) {
1395     unmatched = decl;
1396     family = implFamily;
1397     errorID = diag::err_arc_gained_method_convention;
1398     noteID = diag::note_arc_gained_method_convention;
1399   }
1400
1401   // Indexes into a %select clause in the diagnostic.
1402   enum FamilySelector {
1403     F_alloc, F_copy, F_mutableCopy = F_copy, F_init, F_new
1404   };
1405   FamilySelector familySelector = FamilySelector();
1406
1407   switch (family) {
1408   case OMF_None: llvm_unreachable("logic error, no method convention");
1409   case OMF_retain:
1410   case OMF_release:
1411   case OMF_autorelease:
1412   case OMF_dealloc:
1413   case OMF_finalize:
1414   case OMF_retainCount:
1415   case OMF_self:
1416   case OMF_performSelector:
1417     // Mismatches for these methods don't change ownership
1418     // conventions, so we don't care.
1419     return false;
1420
1421   case OMF_init: familySelector = F_init; break;
1422   case OMF_alloc: familySelector = F_alloc; break;
1423   case OMF_copy: familySelector = F_copy; break;
1424   case OMF_mutableCopy: familySelector = F_mutableCopy; break;
1425   case OMF_new: familySelector = F_new; break;
1426   }
1427
1428   enum ReasonSelector { R_NonObjectReturn, R_UnrelatedReturn };
1429   ReasonSelector reasonSelector;
1430
1431   // The only reason these methods don't fall within their families is
1432   // due to unusual result types.
1433   if (unmatched->getResultType()->isObjCObjectPointerType()) {
1434     reasonSelector = R_UnrelatedReturn;
1435   } else {
1436     reasonSelector = R_NonObjectReturn;
1437   }
1438
1439   S.Diag(impl->getLocation(), errorID) << familySelector << reasonSelector;
1440   S.Diag(decl->getLocation(), noteID) << familySelector << reasonSelector;
1441
1442   return true;
1443 }
1444
1445 void Sema::WarnConflictingTypedMethods(ObjCMethodDecl *ImpMethodDecl,
1446                                        ObjCMethodDecl *MethodDecl,
1447                                        bool IsProtocolMethodDecl) {
1448   if (getLangOpts().ObjCAutoRefCount &&
1449       checkMethodFamilyMismatch(*this, ImpMethodDecl, MethodDecl))
1450     return;
1451
1452   CheckMethodOverrideReturn(*this, ImpMethodDecl, MethodDecl,
1453                             IsProtocolMethodDecl, false,
1454                             true);
1455
1456   for (ObjCMethodDecl::param_iterator IM = ImpMethodDecl->param_begin(),
1457        IF = MethodDecl->param_begin(), EM = ImpMethodDecl->param_end(),
1458        EF = MethodDecl->param_end();
1459        IM != EM && IF != EF; ++IM, ++IF) {
1460     CheckMethodOverrideParam(*this, ImpMethodDecl, MethodDecl, *IM, *IF,
1461                              IsProtocolMethodDecl, false, true);
1462   }
1463
1464   if (ImpMethodDecl->isVariadic() != MethodDecl->isVariadic()) {
1465     Diag(ImpMethodDecl->getLocation(),
1466          diag::warn_conflicting_variadic);
1467     Diag(MethodDecl->getLocation(), diag::note_previous_declaration);
1468   }
1469 }
1470
1471 void Sema::CheckConflictingOverridingMethod(ObjCMethodDecl *Method,
1472                                        ObjCMethodDecl *Overridden,
1473                                        bool IsProtocolMethodDecl) {
1474
1475   CheckMethodOverrideReturn(*this, Method, Overridden,
1476                             IsProtocolMethodDecl, true,
1477                             true);
1478
1479   for (ObjCMethodDecl::param_iterator IM = Method->param_begin(),
1480        IF = Overridden->param_begin(), EM = Method->param_end(),
1481        EF = Overridden->param_end();
1482        IM != EM && IF != EF; ++IM, ++IF) {
1483     CheckMethodOverrideParam(*this, Method, Overridden, *IM, *IF,
1484                              IsProtocolMethodDecl, true, true);
1485   }
1486
1487   if (Method->isVariadic() != Overridden->isVariadic()) {
1488     Diag(Method->getLocation(),
1489          diag::warn_conflicting_overriding_variadic);
1490     Diag(Overridden->getLocation(), diag::note_previous_declaration);
1491   }
1492 }
1493
1494 /// WarnExactTypedMethods - This routine issues a warning if method
1495 /// implementation declaration matches exactly that of its declaration.
1496 void Sema::WarnExactTypedMethods(ObjCMethodDecl *ImpMethodDecl,
1497                                  ObjCMethodDecl *MethodDecl,
1498                                  bool IsProtocolMethodDecl) {
1499   // don't issue warning when protocol method is optional because primary
1500   // class is not required to implement it and it is safe for protocol
1501   // to implement it.
1502   if (MethodDecl->getImplementationControl() == ObjCMethodDecl::Optional)
1503     return;
1504   // don't issue warning when primary class's method is
1505   // depecated/unavailable.
1506   if (MethodDecl->hasAttr<UnavailableAttr>() ||
1507       MethodDecl->hasAttr<DeprecatedAttr>())
1508     return;
1509
1510   bool match = CheckMethodOverrideReturn(*this, ImpMethodDecl, MethodDecl,
1511                                       IsProtocolMethodDecl, false, false);
1512   if (match)
1513     for (ObjCMethodDecl::param_iterator IM = ImpMethodDecl->param_begin(),
1514          IF = MethodDecl->param_begin(), EM = ImpMethodDecl->param_end(),
1515          EF = MethodDecl->param_end();
1516          IM != EM && IF != EF; ++IM, ++IF) {
1517       match = CheckMethodOverrideParam(*this, ImpMethodDecl, MethodDecl,
1518                                        *IM, *IF,
1519                                        IsProtocolMethodDecl, false, false);
1520       if (!match)
1521         break;
1522     }
1523   if (match)
1524     match = (ImpMethodDecl->isVariadic() == MethodDecl->isVariadic());
1525   if (match)
1526     match = !(MethodDecl->isClassMethod() &&
1527               MethodDecl->getSelector() == GetNullarySelector("load", Context));
1528
1529   if (match) {
1530     Diag(ImpMethodDecl->getLocation(),
1531          diag::warn_category_method_impl_match);
1532     Diag(MethodDecl->getLocation(), diag::note_method_declared_at)
1533       << MethodDecl->getDeclName();
1534   }
1535 }
1536
1537 /// FIXME: Type hierarchies in Objective-C can be deep. We could most likely
1538 /// improve the efficiency of selector lookups and type checking by associating
1539 /// with each protocol / interface / category the flattened instance tables. If
1540 /// we used an immutable set to keep the table then it wouldn't add significant
1541 /// memory cost and it would be handy for lookups.
1542
1543 /// CheckProtocolMethodDefs - This routine checks unimplemented methods
1544 /// Declared in protocol, and those referenced by it.
1545 void Sema::CheckProtocolMethodDefs(SourceLocation ImpLoc,
1546                                    ObjCProtocolDecl *PDecl,
1547                                    bool& IncompleteImpl,
1548                                    const SelectorSet &InsMap,
1549                                    const SelectorSet &ClsMap,
1550                                    ObjCContainerDecl *CDecl) {
1551   ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(CDecl);
1552   ObjCInterfaceDecl *IDecl = C ? C->getClassInterface()
1553                                : dyn_cast<ObjCInterfaceDecl>(CDecl);
1554   assert (IDecl && "CheckProtocolMethodDefs - IDecl is null");
1555
1556   ObjCInterfaceDecl *Super = IDecl->getSuperClass();
1557   ObjCInterfaceDecl *NSIDecl = 0;
1558   if (getLangOpts().ObjCRuntime.isNeXTFamily()) {
1559     // check to see if class implements forwardInvocation method and objects
1560     // of this class are derived from 'NSProxy' so that to forward requests
1561     // from one object to another.
1562     // Under such conditions, which means that every method possible is
1563     // implemented in the class, we should not issue "Method definition not
1564     // found" warnings.
1565     // FIXME: Use a general GetUnarySelector method for this.
1566     IdentifierInfo* II = &Context.Idents.get("forwardInvocation");
1567     Selector fISelector = Context.Selectors.getSelector(1, &II);
1568     if (InsMap.count(fISelector))
1569       // Is IDecl derived from 'NSProxy'? If so, no instance methods
1570       // need be implemented in the implementation.
1571       NSIDecl = IDecl->lookupInheritedClass(&Context.Idents.get("NSProxy"));
1572   }
1573
1574   // If a method lookup fails locally we still need to look and see if
1575   // the method was implemented by a base class or an inherited
1576   // protocol. This lookup is slow, but occurs rarely in correct code
1577   // and otherwise would terminate in a warning.
1578
1579   // check unimplemented instance methods.
1580   if (!NSIDecl)
1581     for (ObjCProtocolDecl::instmeth_iterator I = PDecl->instmeth_begin(),
1582          E = PDecl->instmeth_end(); I != E; ++I) {
1583       ObjCMethodDecl *method = *I;
1584       if (method->getImplementationControl() != ObjCMethodDecl::Optional &&
1585           !method->isPropertyAccessor() &&
1586           !InsMap.count(method->getSelector()) &&
1587           (!Super || !Super->lookupInstanceMethod(method->getSelector()))) {
1588             // If a method is not implemented in the category implementation but
1589             // has been declared in its primary class, superclass,
1590             // or in one of their protocols, no need to issue the warning.
1591             // This is because method will be implemented in the primary class
1592             // or one of its super class implementation.
1593
1594             // Ugly, but necessary. Method declared in protcol might have
1595             // have been synthesized due to a property declared in the class which
1596             // uses the protocol.
1597             if (ObjCMethodDecl *MethodInClass =
1598                   IDecl->lookupInstanceMethod(method->getSelector(),
1599                                               true /*shallowCategoryLookup*/))
1600               if (C || MethodInClass->isPropertyAccessor())
1601                 continue;
1602             unsigned DIAG = diag::warn_unimplemented_protocol_method;
1603             if (Diags.getDiagnosticLevel(DIAG, ImpLoc)
1604                 != DiagnosticsEngine::Ignored) {
1605               WarnUndefinedMethod(ImpLoc, method, IncompleteImpl, DIAG);
1606               Diag(method->getLocation(), diag::note_method_declared_at)
1607                 << method->getDeclName();
1608               Diag(CDecl->getLocation(), diag::note_required_for_protocol_at)
1609                 << PDecl->getDeclName();
1610             }
1611           }
1612     }
1613   // check unimplemented class methods
1614   for (ObjCProtocolDecl::classmeth_iterator
1615          I = PDecl->classmeth_begin(), E = PDecl->classmeth_end();
1616        I != E; ++I) {
1617     ObjCMethodDecl *method = *I;
1618     if (method->getImplementationControl() != ObjCMethodDecl::Optional &&
1619         !ClsMap.count(method->getSelector()) &&
1620         (!Super || !Super->lookupClassMethod(method->getSelector()))) {
1621       // See above comment for instance method lookups.
1622       if (C && IDecl->lookupClassMethod(method->getSelector(),
1623                                         true /*shallowCategoryLookup*/))
1624         continue;
1625       unsigned DIAG = diag::warn_unimplemented_protocol_method;
1626       if (Diags.getDiagnosticLevel(DIAG, ImpLoc) !=
1627             DiagnosticsEngine::Ignored) {
1628         WarnUndefinedMethod(ImpLoc, method, IncompleteImpl, DIAG);
1629         Diag(method->getLocation(), diag::note_method_declared_at)
1630           << method->getDeclName();
1631         Diag(IDecl->getLocation(), diag::note_required_for_protocol_at) <<
1632           PDecl->getDeclName();
1633       }
1634     }
1635   }
1636   // Check on this protocols's referenced protocols, recursively.
1637   for (ObjCProtocolDecl::protocol_iterator PI = PDecl->protocol_begin(),
1638        E = PDecl->protocol_end(); PI != E; ++PI)
1639     CheckProtocolMethodDefs(ImpLoc, *PI, IncompleteImpl, InsMap, ClsMap, CDecl);
1640 }
1641
1642 /// MatchAllMethodDeclarations - Check methods declared in interface
1643 /// or protocol against those declared in their implementations.
1644 ///
1645 void Sema::MatchAllMethodDeclarations(const SelectorSet &InsMap,
1646                                       const SelectorSet &ClsMap,
1647                                       SelectorSet &InsMapSeen,
1648                                       SelectorSet &ClsMapSeen,
1649                                       ObjCImplDecl* IMPDecl,
1650                                       ObjCContainerDecl* CDecl,
1651                                       bool &IncompleteImpl,
1652                                       bool ImmediateClass,
1653                                       bool WarnCategoryMethodImpl) {
1654   // Check and see if instance methods in class interface have been
1655   // implemented in the implementation class. If so, their types match.
1656   for (ObjCInterfaceDecl::instmeth_iterator I = CDecl->instmeth_begin(),
1657        E = CDecl->instmeth_end(); I != E; ++I) {
1658     if (InsMapSeen.count((*I)->getSelector()))
1659         continue;
1660     InsMapSeen.insert((*I)->getSelector());
1661     if (!(*I)->isPropertyAccessor() &&
1662         !InsMap.count((*I)->getSelector())) {
1663       if (ImmediateClass)
1664         WarnUndefinedMethod(IMPDecl->getLocation(), *I, IncompleteImpl,
1665                             diag::note_undef_method_impl);
1666       continue;
1667     } else {
1668       ObjCMethodDecl *ImpMethodDecl =
1669         IMPDecl->getInstanceMethod((*I)->getSelector());
1670       assert(CDecl->getInstanceMethod((*I)->getSelector()) &&
1671              "Expected to find the method through lookup as well");
1672       ObjCMethodDecl *MethodDecl = *I;
1673       // ImpMethodDecl may be null as in a @dynamic property.
1674       if (ImpMethodDecl) {
1675         if (!WarnCategoryMethodImpl)
1676           WarnConflictingTypedMethods(ImpMethodDecl, MethodDecl,
1677                                       isa<ObjCProtocolDecl>(CDecl));
1678         else if (!MethodDecl->isPropertyAccessor())
1679           WarnExactTypedMethods(ImpMethodDecl, MethodDecl,
1680                                 isa<ObjCProtocolDecl>(CDecl));
1681       }
1682     }
1683   }
1684
1685   // Check and see if class methods in class interface have been
1686   // implemented in the implementation class. If so, their types match.
1687    for (ObjCInterfaceDecl::classmeth_iterator
1688        I = CDecl->classmeth_begin(), E = CDecl->classmeth_end(); I != E; ++I) {
1689      if (ClsMapSeen.count((*I)->getSelector()))
1690        continue;
1691      ClsMapSeen.insert((*I)->getSelector());
1692     if (!ClsMap.count((*I)->getSelector())) {
1693       if (ImmediateClass)
1694         WarnUndefinedMethod(IMPDecl->getLocation(), *I, IncompleteImpl,
1695                             diag::note_undef_method_impl);
1696     } else {
1697       ObjCMethodDecl *ImpMethodDecl =
1698         IMPDecl->getClassMethod((*I)->getSelector());
1699       assert(CDecl->getClassMethod((*I)->getSelector()) &&
1700              "Expected to find the method through lookup as well");
1701       ObjCMethodDecl *MethodDecl = *I;
1702       if (!WarnCategoryMethodImpl)
1703         WarnConflictingTypedMethods(ImpMethodDecl, MethodDecl,
1704                                     isa<ObjCProtocolDecl>(CDecl));
1705       else
1706         WarnExactTypedMethods(ImpMethodDecl, MethodDecl,
1707                               isa<ObjCProtocolDecl>(CDecl));
1708     }
1709   }
1710
1711   if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl> (CDecl)) {
1712     // when checking that methods in implementation match their declaration,
1713     // i.e. when WarnCategoryMethodImpl is false, check declarations in class
1714     // extension; as well as those in categories.
1715     if (!WarnCategoryMethodImpl)
1716       for (const ObjCCategoryDecl *CDeclChain = I->getCategoryList();
1717            CDeclChain; CDeclChain = CDeclChain->getNextClassCategory())
1718         MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
1719                                    IMPDecl,
1720                                    const_cast<ObjCCategoryDecl *>(CDeclChain),
1721                                    IncompleteImpl, false,
1722                                    WarnCategoryMethodImpl);
1723     else
1724       // Also methods in class extensions need be looked at next.
1725       for (const ObjCCategoryDecl *ClsExtDecl = I->getFirstClassExtension();
1726            ClsExtDecl; ClsExtDecl = ClsExtDecl->getNextClassExtension())
1727         MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
1728                                    IMPDecl,
1729                                    const_cast<ObjCCategoryDecl *>(ClsExtDecl),
1730                                    IncompleteImpl, false,
1731                                    WarnCategoryMethodImpl);
1732
1733     // Check for any implementation of a methods declared in protocol.
1734     for (ObjCInterfaceDecl::all_protocol_iterator
1735           PI = I->all_referenced_protocol_begin(),
1736           E = I->all_referenced_protocol_end(); PI != E; ++PI)
1737       MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
1738                                  IMPDecl,
1739                                  (*PI), IncompleteImpl, false,
1740                                  WarnCategoryMethodImpl);
1741
1742     // FIXME. For now, we are not checking for extact match of methods
1743     // in category implementation and its primary class's super class.
1744     if (!WarnCategoryMethodImpl && I->getSuperClass())
1745       MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
1746                                  IMPDecl,
1747                                  I->getSuperClass(), IncompleteImpl, false);
1748   }
1749 }
1750
1751 /// CheckCategoryVsClassMethodMatches - Checks that methods implemented in
1752 /// category matches with those implemented in its primary class and
1753 /// warns each time an exact match is found.
1754 void Sema::CheckCategoryVsClassMethodMatches(
1755                                   ObjCCategoryImplDecl *CatIMPDecl) {
1756   SelectorSet InsMap, ClsMap;
1757
1758   for (ObjCImplementationDecl::instmeth_iterator
1759        I = CatIMPDecl->instmeth_begin(),
1760        E = CatIMPDecl->instmeth_end(); I!=E; ++I)
1761     InsMap.insert((*I)->getSelector());
1762
1763   for (ObjCImplementationDecl::classmeth_iterator
1764        I = CatIMPDecl->classmeth_begin(),
1765        E = CatIMPDecl->classmeth_end(); I != E; ++I)
1766     ClsMap.insert((*I)->getSelector());
1767   if (InsMap.empty() && ClsMap.empty())
1768     return;
1769
1770   // Get category's primary class.
1771   ObjCCategoryDecl *CatDecl = CatIMPDecl->getCategoryDecl();
1772   if (!CatDecl)
1773     return;
1774   ObjCInterfaceDecl *IDecl = CatDecl->getClassInterface();
1775   if (!IDecl)
1776     return;
1777   SelectorSet InsMapSeen, ClsMapSeen;
1778   bool IncompleteImpl = false;
1779   MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
1780                              CatIMPDecl, IDecl,
1781                              IncompleteImpl, false,
1782                              true /*WarnCategoryMethodImpl*/);
1783 }
1784
1785 void Sema::ImplMethodsVsClassMethods(Scope *S, ObjCImplDecl* IMPDecl,
1786                                      ObjCContainerDecl* CDecl,
1787                                      bool IncompleteImpl) {
1788   SelectorSet InsMap;
1789   // Check and see if instance methods in class interface have been
1790   // implemented in the implementation class.
1791   for (ObjCImplementationDecl::instmeth_iterator
1792          I = IMPDecl->instmeth_begin(), E = IMPDecl->instmeth_end(); I!=E; ++I)
1793     InsMap.insert((*I)->getSelector());
1794
1795   // Check and see if properties declared in the interface have either 1)
1796   // an implementation or 2) there is a @synthesize/@dynamic implementation
1797   // of the property in the @implementation.
1798   if (const ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(CDecl))
1799     if  (!(LangOpts.ObjCDefaultSynthProperties &&
1800            LangOpts.ObjCRuntime.isNonFragile()) ||
1801          IDecl->isObjCRequiresPropertyDefs())
1802       DiagnoseUnimplementedProperties(S, IMPDecl, CDecl, InsMap);
1803
1804   SelectorSet ClsMap;
1805   for (ObjCImplementationDecl::classmeth_iterator
1806        I = IMPDecl->classmeth_begin(),
1807        E = IMPDecl->classmeth_end(); I != E; ++I)
1808     ClsMap.insert((*I)->getSelector());
1809
1810   // Check for type conflict of methods declared in a class/protocol and
1811   // its implementation; if any.
1812   SelectorSet InsMapSeen, ClsMapSeen;
1813   MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
1814                              IMPDecl, CDecl,
1815                              IncompleteImpl, true);
1816
1817   // check all methods implemented in category against those declared
1818   // in its primary class.
1819   if (ObjCCategoryImplDecl *CatDecl =
1820         dyn_cast<ObjCCategoryImplDecl>(IMPDecl))
1821     CheckCategoryVsClassMethodMatches(CatDecl);
1822
1823   // Check the protocol list for unimplemented methods in the @implementation
1824   // class.
1825   // Check and see if class methods in class interface have been
1826   // implemented in the implementation class.
1827
1828   if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl> (CDecl)) {
1829     for (ObjCInterfaceDecl::all_protocol_iterator
1830           PI = I->all_referenced_protocol_begin(),
1831           E = I->all_referenced_protocol_end(); PI != E; ++PI)
1832       CheckProtocolMethodDefs(IMPDecl->getLocation(), *PI, IncompleteImpl,
1833                               InsMap, ClsMap, I);
1834     // Check class extensions (unnamed categories)
1835     for (const ObjCCategoryDecl *Categories = I->getFirstClassExtension();
1836          Categories; Categories = Categories->getNextClassExtension())
1837       ImplMethodsVsClassMethods(S, IMPDecl,
1838                                 const_cast<ObjCCategoryDecl*>(Categories),
1839                                 IncompleteImpl);
1840   } else if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(CDecl)) {
1841     // For extended class, unimplemented methods in its protocols will
1842     // be reported in the primary class.
1843     if (!C->IsClassExtension()) {
1844       for (ObjCCategoryDecl::protocol_iterator PI = C->protocol_begin(),
1845            E = C->protocol_end(); PI != E; ++PI)
1846         CheckProtocolMethodDefs(IMPDecl->getLocation(), *PI, IncompleteImpl,
1847                                 InsMap, ClsMap, CDecl);
1848       // Report unimplemented properties in the category as well.
1849       // When reporting on missing setter/getters, do not report when
1850       // setter/getter is implemented in category's primary class
1851       // implementation.
1852       if (ObjCInterfaceDecl *ID = C->getClassInterface())
1853         if (ObjCImplDecl *IMP = ID->getImplementation()) {
1854           for (ObjCImplementationDecl::instmeth_iterator
1855                I = IMP->instmeth_begin(), E = IMP->instmeth_end(); I!=E; ++I)
1856             InsMap.insert((*I)->getSelector());
1857         }
1858       DiagnoseUnimplementedProperties(S, IMPDecl, CDecl, InsMap);
1859     }
1860   } else
1861     llvm_unreachable("invalid ObjCContainerDecl type.");
1862 }
1863
1864 /// ActOnForwardClassDeclaration -
1865 Sema::DeclGroupPtrTy
1866 Sema::ActOnForwardClassDeclaration(SourceLocation AtClassLoc,
1867                                    IdentifierInfo **IdentList,
1868                                    SourceLocation *IdentLocs,
1869                                    unsigned NumElts) {
1870   SmallVector<Decl *, 8> DeclsInGroup;
1871   for (unsigned i = 0; i != NumElts; ++i) {
1872     // Check for another declaration kind with the same name.
1873     NamedDecl *PrevDecl
1874       = LookupSingleName(TUScope, IdentList[i], IdentLocs[i],
1875                          LookupOrdinaryName, ForRedeclaration);
1876     if (PrevDecl && PrevDecl->isTemplateParameter()) {
1877       // Maybe we will complain about the shadowed template parameter.
1878       DiagnoseTemplateParameterShadow(AtClassLoc, PrevDecl);
1879       // Just pretend that we didn't see the previous declaration.
1880       PrevDecl = 0;
1881     }
1882
1883     if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
1884       // GCC apparently allows the following idiom:
1885       //
1886       // typedef NSObject < XCElementTogglerP > XCElementToggler;
1887       // @class XCElementToggler;
1888       //
1889       // Here we have chosen to ignore the forward class declaration
1890       // with a warning. Since this is the implied behavior.
1891       TypedefNameDecl *TDD = dyn_cast<TypedefNameDecl>(PrevDecl);
1892       if (!TDD || !TDD->getUnderlyingType()->isObjCObjectType()) {
1893         Diag(AtClassLoc, diag::err_redefinition_different_kind) << IdentList[i];
1894         Diag(PrevDecl->getLocation(), diag::note_previous_definition);
1895       } else {
1896         // a forward class declaration matching a typedef name of a class refers
1897         // to the underlying class. Just ignore the forward class with a warning
1898         // as this will force the intended behavior which is to lookup the typedef
1899         // name.
1900         if (isa<ObjCObjectType>(TDD->getUnderlyingType())) {
1901           Diag(AtClassLoc, diag::warn_forward_class_redefinition) << IdentList[i];
1902           Diag(PrevDecl->getLocation(), diag::note_previous_definition);
1903           continue;
1904         }
1905       }
1906     }
1907
1908     // Create a declaration to describe this forward declaration.
1909     ObjCInterfaceDecl *PrevIDecl
1910       = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
1911     ObjCInterfaceDecl *IDecl
1912       = ObjCInterfaceDecl::Create(Context, CurContext, AtClassLoc,
1913                                   IdentList[i], PrevIDecl, IdentLocs[i]);
1914     IDecl->setAtEndRange(IdentLocs[i]);
1915
1916     PushOnScopeChains(IDecl, TUScope);
1917     CheckObjCDeclScope(IDecl);
1918     DeclsInGroup.push_back(IDecl);
1919   }
1920
1921   return BuildDeclaratorGroup(DeclsInGroup.data(), DeclsInGroup.size(), false);
1922 }
1923
1924 static bool tryMatchRecordTypes(ASTContext &Context,
1925                                 Sema::MethodMatchStrategy strategy,
1926                                 const Type *left, const Type *right);
1927
1928 static bool matchTypes(ASTContext &Context, Sema::MethodMatchStrategy strategy,
1929                        QualType leftQT, QualType rightQT) {
1930   const Type *left =
1931     Context.getCanonicalType(leftQT).getUnqualifiedType().getTypePtr();
1932   const Type *right =
1933     Context.getCanonicalType(rightQT).getUnqualifiedType().getTypePtr();
1934
1935   if (left == right) return true;
1936
1937   // If we're doing a strict match, the types have to match exactly.
1938   if (strategy == Sema::MMS_strict) return false;
1939
1940   if (left->isIncompleteType() || right->isIncompleteType()) return false;
1941
1942   // Otherwise, use this absurdly complicated algorithm to try to
1943   // validate the basic, low-level compatibility of the two types.
1944
1945   // As a minimum, require the sizes and alignments to match.
1946   if (Context.getTypeInfo(left) != Context.getTypeInfo(right))
1947     return false;
1948
1949   // Consider all the kinds of non-dependent canonical types:
1950   // - functions and arrays aren't possible as return and parameter types
1951
1952   // - vector types of equal size can be arbitrarily mixed
1953   if (isa<VectorType>(left)) return isa<VectorType>(right);
1954   if (isa<VectorType>(right)) return false;
1955
1956   // - references should only match references of identical type
1957   // - structs, unions, and Objective-C objects must match more-or-less
1958   //   exactly
1959   // - everything else should be a scalar
1960   if (!left->isScalarType() || !right->isScalarType())
1961     return tryMatchRecordTypes(Context, strategy, left, right);
1962
1963   // Make scalars agree in kind, except count bools as chars, and group
1964   // all non-member pointers together.
1965   Type::ScalarTypeKind leftSK = left->getScalarTypeKind();
1966   Type::ScalarTypeKind rightSK = right->getScalarTypeKind();
1967   if (leftSK == Type::STK_Bool) leftSK = Type::STK_Integral;
1968   if (rightSK == Type::STK_Bool) rightSK = Type::STK_Integral;
1969   if (leftSK == Type::STK_CPointer || leftSK == Type::STK_BlockPointer)
1970     leftSK = Type::STK_ObjCObjectPointer;
1971   if (rightSK == Type::STK_CPointer || rightSK == Type::STK_BlockPointer)
1972     rightSK = Type::STK_ObjCObjectPointer;
1973
1974   // Note that data member pointers and function member pointers don't
1975   // intermix because of the size differences.
1976
1977   return (leftSK == rightSK);
1978 }
1979
1980 static bool tryMatchRecordTypes(ASTContext &Context,
1981                                 Sema::MethodMatchStrategy strategy,
1982                                 const Type *lt, const Type *rt) {
1983   assert(lt && rt && lt != rt);
1984
1985   if (!isa<RecordType>(lt) || !isa<RecordType>(rt)) return false;
1986   RecordDecl *left = cast<RecordType>(lt)->getDecl();
1987   RecordDecl *right = cast<RecordType>(rt)->getDecl();
1988
1989   // Require union-hood to match.
1990   if (left->isUnion() != right->isUnion()) return false;
1991
1992   // Require an exact match if either is non-POD.
1993   if ((isa<CXXRecordDecl>(left) && !cast<CXXRecordDecl>(left)->isPOD()) ||
1994       (isa<CXXRecordDecl>(right) && !cast<CXXRecordDecl>(right)->isPOD()))
1995     return false;
1996
1997   // Require size and alignment to match.
1998   if (Context.getTypeInfo(lt) != Context.getTypeInfo(rt)) return false;
1999
2000   // Require fields to match.
2001   RecordDecl::field_iterator li = left->field_begin(), le = left->field_end();
2002   RecordDecl::field_iterator ri = right->field_begin(), re = right->field_end();
2003   for (; li != le && ri != re; ++li, ++ri) {
2004     if (!matchTypes(Context, strategy, li->getType(), ri->getType()))
2005       return false;
2006   }
2007   return (li == le && ri == re);
2008 }
2009
2010 /// MatchTwoMethodDeclarations - Checks that two methods have matching type and
2011 /// returns true, or false, accordingly.
2012 /// TODO: Handle protocol list; such as id<p1,p2> in type comparisons
2013 bool Sema::MatchTwoMethodDeclarations(const ObjCMethodDecl *left,
2014                                       const ObjCMethodDecl *right,
2015                                       MethodMatchStrategy strategy) {
2016   if (!matchTypes(Context, strategy,
2017                   left->getResultType(), right->getResultType()))
2018     return false;
2019
2020   if (getLangOpts().ObjCAutoRefCount &&
2021       (left->hasAttr<NSReturnsRetainedAttr>()
2022          != right->hasAttr<NSReturnsRetainedAttr>() ||
2023        left->hasAttr<NSConsumesSelfAttr>()
2024          != right->hasAttr<NSConsumesSelfAttr>()))
2025     return false;
2026
2027   ObjCMethodDecl::param_const_iterator
2028     li = left->param_begin(), le = left->param_end(), ri = right->param_begin(),
2029     re = right->param_end();
2030
2031   for (; li != le && ri != re; ++li, ++ri) {
2032     assert(ri != right->param_end() && "Param mismatch");
2033     const ParmVarDecl *lparm = *li, *rparm = *ri;
2034
2035     if (!matchTypes(Context, strategy, lparm->getType(), rparm->getType()))
2036       return false;
2037
2038     if (getLangOpts().ObjCAutoRefCount &&
2039         lparm->hasAttr<NSConsumedAttr>() != rparm->hasAttr<NSConsumedAttr>())
2040       return false;
2041   }
2042   return true;
2043 }
2044
2045 void Sema::addMethodToGlobalList(ObjCMethodList *List, ObjCMethodDecl *Method) {
2046   // If the list is empty, make it a singleton list.
2047   if (List->Method == 0) {
2048     List->Method = Method;
2049     List->Next = 0;
2050     return;
2051   }
2052
2053   // We've seen a method with this name, see if we have already seen this type
2054   // signature.
2055   ObjCMethodList *Previous = List;
2056   for (; List; Previous = List, List = List->Next) {
2057     if (!MatchTwoMethodDeclarations(Method, List->Method))
2058       continue;
2059
2060     ObjCMethodDecl *PrevObjCMethod = List->Method;
2061
2062     // Propagate the 'defined' bit.
2063     if (Method->isDefined())
2064       PrevObjCMethod->setDefined(true);
2065
2066     // If a method is deprecated, push it in the global pool.
2067     // This is used for better diagnostics.
2068     if (Method->isDeprecated()) {
2069       if (!PrevObjCMethod->isDeprecated())
2070         List->Method = Method;
2071     }
2072     // If new method is unavailable, push it into global pool
2073     // unless previous one is deprecated.
2074     if (Method->isUnavailable()) {
2075       if (PrevObjCMethod->getAvailability() < AR_Deprecated)
2076         List->Method = Method;
2077     }
2078
2079     return;
2080   }
2081
2082   // We have a new signature for an existing method - add it.
2083   // This is extremely rare. Only 1% of Cocoa selectors are "overloaded".
2084   ObjCMethodList *Mem = BumpAlloc.Allocate<ObjCMethodList>();
2085   Previous->Next = new (Mem) ObjCMethodList(Method, 0);
2086 }
2087
2088 /// \brief Read the contents of the method pool for a given selector from
2089 /// external storage.
2090 void Sema::ReadMethodPool(Selector Sel) {
2091   assert(ExternalSource && "We need an external AST source");
2092   ExternalSource->ReadMethodPool(Sel);
2093 }
2094
2095 void Sema::AddMethodToGlobalPool(ObjCMethodDecl *Method, bool impl,
2096                                  bool instance) {
2097   // Ignore methods of invalid containers.
2098   if (cast<Decl>(Method->getDeclContext())->isInvalidDecl())
2099     return;
2100
2101   if (ExternalSource)
2102     ReadMethodPool(Method->getSelector());
2103
2104   GlobalMethodPool::iterator Pos = MethodPool.find(Method->getSelector());
2105   if (Pos == MethodPool.end())
2106     Pos = MethodPool.insert(std::make_pair(Method->getSelector(),
2107                                            GlobalMethods())).first;
2108
2109   Method->setDefined(impl);
2110
2111   ObjCMethodList &Entry = instance ? Pos->second.first : Pos->second.second;
2112   addMethodToGlobalList(&Entry, Method);
2113 }
2114
2115 /// Determines if this is an "acceptable" loose mismatch in the global
2116 /// method pool.  This exists mostly as a hack to get around certain
2117 /// global mismatches which we can't afford to make warnings / errors.
2118 /// Really, what we want is a way to take a method out of the global
2119 /// method pool.
2120 static bool isAcceptableMethodMismatch(ObjCMethodDecl *chosen,
2121                                        ObjCMethodDecl *other) {
2122   if (!chosen->isInstanceMethod())
2123     return false;
2124
2125   Selector sel = chosen->getSelector();
2126   if (!sel.isUnarySelector() || sel.getNameForSlot(0) != "length")
2127     return false;
2128
2129   // Don't complain about mismatches for -length if the method we
2130   // chose has an integral result type.
2131   return (chosen->getResultType()->isIntegerType());
2132 }
2133
2134 ObjCMethodDecl *Sema::LookupMethodInGlobalPool(Selector Sel, SourceRange R,
2135                                                bool receiverIdOrClass,
2136                                                bool warn, bool instance) {
2137   if (ExternalSource)
2138     ReadMethodPool(Sel);
2139
2140   GlobalMethodPool::iterator Pos = MethodPool.find(Sel);
2141   if (Pos == MethodPool.end())
2142     return 0;
2143
2144   ObjCMethodList &MethList = instance ? Pos->second.first : Pos->second.second;
2145
2146   if (warn && MethList.Method && MethList.Next) {
2147     bool issueDiagnostic = false, issueError = false;
2148
2149     // We support a warning which complains about *any* difference in
2150     // method signature.
2151     bool strictSelectorMatch =
2152       (receiverIdOrClass && warn &&
2153        (Diags.getDiagnosticLevel(diag::warn_strict_multiple_method_decl,
2154                                  R.getBegin()) !=
2155       DiagnosticsEngine::Ignored));
2156     if (strictSelectorMatch)
2157       for (ObjCMethodList *Next = MethList.Next; Next; Next = Next->Next) {
2158         if (!MatchTwoMethodDeclarations(MethList.Method, Next->Method,
2159                                         MMS_strict)) {
2160           issueDiagnostic = true;
2161           break;
2162         }
2163       }
2164
2165     // If we didn't see any strict differences, we won't see any loose
2166     // differences.  In ARC, however, we also need to check for loose
2167     // mismatches, because most of them are errors.
2168     if (!strictSelectorMatch ||
2169         (issueDiagnostic && getLangOpts().ObjCAutoRefCount))
2170       for (ObjCMethodList *Next = MethList.Next; Next; Next = Next->Next) {
2171         // This checks if the methods differ in type mismatch.
2172         if (!MatchTwoMethodDeclarations(MethList.Method, Next->Method,
2173                                         MMS_loose) &&
2174             !isAcceptableMethodMismatch(MethList.Method, Next->Method)) {
2175           issueDiagnostic = true;
2176           if (getLangOpts().ObjCAutoRefCount)
2177             issueError = true;
2178           break;
2179         }
2180       }
2181
2182     if (issueDiagnostic) {
2183       if (issueError)
2184         Diag(R.getBegin(), diag::err_arc_multiple_method_decl) << Sel << R;
2185       else if (strictSelectorMatch)
2186         Diag(R.getBegin(), diag::warn_strict_multiple_method_decl) << Sel << R;
2187       else
2188         Diag(R.getBegin(), diag::warn_multiple_method_decl) << Sel << R;
2189
2190       Diag(MethList.Method->getLocStart(),
2191            issueError ? diag::note_possibility : diag::note_using)
2192         << MethList.Method->getSourceRange();
2193       for (ObjCMethodList *Next = MethList.Next; Next; Next = Next->Next)
2194         Diag(Next->Method->getLocStart(), diag::note_also_found)
2195           << Next->Method->getSourceRange();
2196     }
2197   }
2198   return MethList.Method;
2199 }
2200
2201 ObjCMethodDecl *Sema::LookupImplementedMethodInGlobalPool(Selector Sel) {
2202   GlobalMethodPool::iterator Pos = MethodPool.find(Sel);
2203   if (Pos == MethodPool.end())
2204     return 0;
2205
2206   GlobalMethods &Methods = Pos->second;
2207
2208   if (Methods.first.Method && Methods.first.Method->isDefined())
2209     return Methods.first.Method;
2210   if (Methods.second.Method && Methods.second.Method->isDefined())
2211     return Methods.second.Method;
2212   return 0;
2213 }
2214
2215 /// DiagnoseDuplicateIvars -
2216 /// Check for duplicate ivars in the entire class at the start of
2217 /// \@implementation. This becomes necesssary because class extension can
2218 /// add ivars to a class in random order which will not be known until
2219 /// class's \@implementation is seen.
2220 void Sema::DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID,
2221                                   ObjCInterfaceDecl *SID) {
2222   for (ObjCInterfaceDecl::ivar_iterator IVI = ID->ivar_begin(),
2223        IVE = ID->ivar_end(); IVI != IVE; ++IVI) {
2224     ObjCIvarDecl* Ivar = *IVI;
2225     if (Ivar->isInvalidDecl())
2226       continue;
2227     if (IdentifierInfo *II = Ivar->getIdentifier()) {
2228       ObjCIvarDecl* prevIvar = SID->lookupInstanceVariable(II);
2229       if (prevIvar) {
2230         Diag(Ivar->getLocation(), diag::err_duplicate_member) << II;
2231         Diag(prevIvar->getLocation(), diag::note_previous_declaration);
2232         Ivar->setInvalidDecl();
2233       }
2234     }
2235   }
2236 }
2237
2238 Sema::ObjCContainerKind Sema::getObjCContainerKind() const {
2239   switch (CurContext->getDeclKind()) {
2240     case Decl::ObjCInterface:
2241       return Sema::OCK_Interface;
2242     case Decl::ObjCProtocol:
2243       return Sema::OCK_Protocol;
2244     case Decl::ObjCCategory:
2245       if (dyn_cast<ObjCCategoryDecl>(CurContext)->IsClassExtension())
2246         return Sema::OCK_ClassExtension;
2247       else
2248         return Sema::OCK_Category;
2249     case Decl::ObjCImplementation:
2250       return Sema::OCK_Implementation;
2251     case Decl::ObjCCategoryImpl:
2252       return Sema::OCK_CategoryImplementation;
2253
2254     default:
2255       return Sema::OCK_None;
2256   }
2257 }
2258
2259 // Note: For class/category implemenations, allMethods/allProperties is
2260 // always null.
2261 Decl *Sema::ActOnAtEnd(Scope *S, SourceRange AtEnd,
2262                        Decl **allMethods, unsigned allNum,
2263                        Decl **allProperties, unsigned pNum,
2264                        DeclGroupPtrTy *allTUVars, unsigned tuvNum) {
2265
2266   if (getObjCContainerKind() == Sema::OCK_None)
2267     return 0;
2268
2269   assert(AtEnd.isValid() && "Invalid location for '@end'");
2270
2271   ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
2272   Decl *ClassDecl = cast<Decl>(OCD);
2273
2274   bool isInterfaceDeclKind =
2275         isa<ObjCInterfaceDecl>(ClassDecl) || isa<ObjCCategoryDecl>(ClassDecl)
2276          || isa<ObjCProtocolDecl>(ClassDecl);
2277   bool checkIdenticalMethods = isa<ObjCImplementationDecl>(ClassDecl);
2278
2279   // FIXME: Remove these and use the ObjCContainerDecl/DeclContext.
2280   llvm::DenseMap<Selector, const ObjCMethodDecl*> InsMap;
2281   llvm::DenseMap<Selector, const ObjCMethodDecl*> ClsMap;
2282
2283   for (unsigned i = 0; i < allNum; i++ ) {
2284     ObjCMethodDecl *Method =
2285       cast_or_null<ObjCMethodDecl>(allMethods[i]);
2286
2287     if (!Method) continue;  // Already issued a diagnostic.
2288     if (Method->isInstanceMethod()) {
2289       /// Check for instance method of the same name with incompatible types
2290       const ObjCMethodDecl *&PrevMethod = InsMap[Method->getSelector()];
2291       bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod)
2292                               : false;
2293       if ((isInterfaceDeclKind && PrevMethod && !match)
2294           || (checkIdenticalMethods && match)) {
2295           Diag(Method->getLocation(), diag::err_duplicate_method_decl)
2296             << Method->getDeclName();
2297           Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
2298         Method->setInvalidDecl();
2299       } else {
2300         if (PrevMethod) {
2301           Method->setAsRedeclaration(PrevMethod);
2302           if (!Context.getSourceManager().isInSystemHeader(
2303                  Method->getLocation()))
2304             Diag(Method->getLocation(), diag::warn_duplicate_method_decl)
2305               << Method->getDeclName();
2306           Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
2307         }
2308         InsMap[Method->getSelector()] = Method;
2309         /// The following allows us to typecheck messages to "id".
2310         AddInstanceMethodToGlobalPool(Method);
2311       }
2312     } else {
2313       /// Check for class method of the same name with incompatible types
2314       const ObjCMethodDecl *&PrevMethod = ClsMap[Method->getSelector()];
2315       bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod)
2316                               : false;
2317       if ((isInterfaceDeclKind && PrevMethod && !match)
2318           || (checkIdenticalMethods && match)) {
2319         Diag(Method->getLocation(), diag::err_duplicate_method_decl)
2320           << Method->getDeclName();
2321         Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
2322         Method->setInvalidDecl();
2323       } else {
2324         if (PrevMethod) {
2325           Method->setAsRedeclaration(PrevMethod);
2326           if (!Context.getSourceManager().isInSystemHeader(
2327                  Method->getLocation()))
2328             Diag(Method->getLocation(), diag::warn_duplicate_method_decl)
2329               << Method->getDeclName();
2330           Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
2331         }
2332         ClsMap[Method->getSelector()] = Method;
2333         AddFactoryMethodToGlobalPool(Method);
2334       }
2335     }
2336   }
2337   if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) {
2338     // Compares properties declared in this class to those of its
2339     // super class.
2340     ComparePropertiesInBaseAndSuper(I);
2341     CompareProperties(I, I);
2342   } else if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(ClassDecl)) {
2343     // Categories are used to extend the class by declaring new methods.
2344     // By the same token, they are also used to add new properties. No
2345     // need to compare the added property to those in the class.
2346
2347     // Compare protocol properties with those in category
2348     CompareProperties(C, C);
2349     if (C->IsClassExtension()) {
2350       ObjCInterfaceDecl *CCPrimary = C->getClassInterface();
2351       DiagnoseClassExtensionDupMethods(C, CCPrimary);
2352     }
2353   }
2354   if (ObjCContainerDecl *CDecl = dyn_cast<ObjCContainerDecl>(ClassDecl)) {
2355     if (CDecl->getIdentifier())
2356       // ProcessPropertyDecl is responsible for diagnosing conflicts with any
2357       // user-defined setter/getter. It also synthesizes setter/getter methods
2358       // and adds them to the DeclContext and global method pools.
2359       for (ObjCContainerDecl::prop_iterator I = CDecl->prop_begin(),
2360                                             E = CDecl->prop_end();
2361            I != E; ++I)
2362         ProcessPropertyDecl(*I, CDecl);
2363     CDecl->setAtEndRange(AtEnd);
2364   }
2365   if (ObjCImplementationDecl *IC=dyn_cast<ObjCImplementationDecl>(ClassDecl)) {
2366     IC->setAtEndRange(AtEnd);
2367     if (ObjCInterfaceDecl* IDecl = IC->getClassInterface()) {
2368       // Any property declared in a class extension might have user
2369       // declared setter or getter in current class extension or one
2370       // of the other class extensions. Mark them as synthesized as
2371       // property will be synthesized when property with same name is
2372       // seen in the @implementation.
2373       for (const ObjCCategoryDecl *ClsExtDecl =
2374            IDecl->getFirstClassExtension();
2375            ClsExtDecl; ClsExtDecl = ClsExtDecl->getNextClassExtension()) {
2376         for (ObjCContainerDecl::prop_iterator I = ClsExtDecl->prop_begin(),
2377              E = ClsExtDecl->prop_end(); I != E; ++I) {
2378           ObjCPropertyDecl *Property = *I;
2379           // Skip over properties declared @dynamic
2380           if (const ObjCPropertyImplDecl *PIDecl
2381               = IC->FindPropertyImplDecl(Property->getIdentifier()))
2382             if (PIDecl->getPropertyImplementation()
2383                   == ObjCPropertyImplDecl::Dynamic)
2384               continue;
2385
2386           for (const ObjCCategoryDecl *CExtDecl =
2387                IDecl->getFirstClassExtension();
2388                CExtDecl; CExtDecl = CExtDecl->getNextClassExtension()) {
2389             if (ObjCMethodDecl *GetterMethod =
2390                 CExtDecl->getInstanceMethod(Property->getGetterName()))
2391               GetterMethod->setPropertyAccessor(true);
2392             if (!Property->isReadOnly())
2393               if (ObjCMethodDecl *SetterMethod =
2394                   CExtDecl->getInstanceMethod(Property->getSetterName()))
2395                 SetterMethod->setPropertyAccessor(true);
2396           }
2397         }
2398       }
2399       ImplMethodsVsClassMethods(S, IC, IDecl);
2400       AtomicPropertySetterGetterRules(IC, IDecl);
2401       DiagnoseOwningPropertyGetterSynthesis(IC);
2402
2403       bool HasRootClassAttr = IDecl->hasAttr<ObjCRootClassAttr>();
2404       if (IDecl->getSuperClass() == NULL) {
2405         // This class has no superclass, so check that it has been marked with
2406         // __attribute((objc_root_class)).
2407         if (!HasRootClassAttr) {
2408           SourceLocation DeclLoc(IDecl->getLocation());
2409           SourceLocation SuperClassLoc(PP.getLocForEndOfToken(DeclLoc));
2410           Diag(DeclLoc, diag::warn_objc_root_class_missing)
2411             << IDecl->getIdentifier();
2412           // See if NSObject is in the current scope, and if it is, suggest
2413           // adding " : NSObject " to the class declaration.
2414           NamedDecl *IF = LookupSingleName(TUScope,
2415                                            NSAPIObj->getNSClassId(NSAPI::ClassId_NSObject),
2416                                            DeclLoc, LookupOrdinaryName);
2417           ObjCInterfaceDecl *NSObjectDecl = dyn_cast_or_null<ObjCInterfaceDecl>(IF);
2418           if (NSObjectDecl && NSObjectDecl->getDefinition()) {
2419             Diag(SuperClassLoc, diag::note_objc_needs_superclass)
2420               << FixItHint::CreateInsertion(SuperClassLoc, " : NSObject ");
2421           } else {
2422             Diag(SuperClassLoc, diag::note_objc_needs_superclass);
2423           }
2424         }
2425       } else if (HasRootClassAttr) {
2426         // Complain that only root classes may have this attribute.
2427         Diag(IDecl->getLocation(), diag::err_objc_root_class_subclass);
2428       }
2429
2430       if (LangOpts.ObjCRuntime.isNonFragile()) {
2431         while (IDecl->getSuperClass()) {
2432           DiagnoseDuplicateIvars(IDecl, IDecl->getSuperClass());
2433           IDecl = IDecl->getSuperClass();
2434         }
2435       }
2436     }
2437     SetIvarInitializers(IC);
2438   } else if (ObjCCategoryImplDecl* CatImplClass =
2439                                    dyn_cast<ObjCCategoryImplDecl>(ClassDecl)) {
2440     CatImplClass->setAtEndRange(AtEnd);
2441
2442     // Find category interface decl and then check that all methods declared
2443     // in this interface are implemented in the category @implementation.
2444     if (ObjCInterfaceDecl* IDecl = CatImplClass->getClassInterface()) {
2445       for (ObjCCategoryDecl *Categories = IDecl->getCategoryList();
2446            Categories; Categories = Categories->getNextClassCategory()) {
2447         if (Categories->getIdentifier() == CatImplClass->getIdentifier()) {
2448           ImplMethodsVsClassMethods(S, CatImplClass, Categories);
2449           break;
2450         }
2451       }
2452     }
2453   }
2454   if (isInterfaceDeclKind) {
2455     // Reject invalid vardecls.
2456     for (unsigned i = 0; i != tuvNum; i++) {
2457       DeclGroupRef DG = allTUVars[i].getAsVal<DeclGroupRef>();
2458       for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
2459         if (VarDecl *VDecl = dyn_cast<VarDecl>(*I)) {
2460           if (!VDecl->hasExternalStorage())
2461             Diag(VDecl->getLocation(), diag::err_objc_var_decl_inclass);
2462         }
2463     }
2464   }
2465   ActOnObjCContainerFinishDefinition();
2466
2467   for (unsigned i = 0; i != tuvNum; i++) {
2468     DeclGroupRef DG = allTUVars[i].getAsVal<DeclGroupRef>();
2469     for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
2470       (*I)->setTopLevelDeclInObjCContainer();
2471     Consumer.HandleTopLevelDeclInObjCContainer(DG);
2472   }
2473
2474   ActOnDocumentableDecl(ClassDecl);
2475   return ClassDecl;
2476 }
2477
2478
2479 /// CvtQTToAstBitMask - utility routine to produce an AST bitmask for
2480 /// objective-c's type qualifier from the parser version of the same info.
2481 static Decl::ObjCDeclQualifier
2482 CvtQTToAstBitMask(ObjCDeclSpec::ObjCDeclQualifier PQTVal) {
2483   return (Decl::ObjCDeclQualifier) (unsigned) PQTVal;
2484 }
2485
2486 static inline
2487 unsigned countAlignAttr(const AttrVec &A) {
2488   unsigned count=0;
2489   for (AttrVec::const_iterator i = A.begin(), e = A.end(); i != e; ++i)
2490     if ((*i)->getKind() == attr::Aligned)
2491       ++count;
2492   return count;
2493 }
2494
2495 static inline
2496 bool containsInvalidMethodImplAttribute(ObjCMethodDecl *IMD,
2497                                         const AttrVec &A) {
2498   // If method is only declared in implementation (private method),
2499   // No need to issue any diagnostics on method definition with attributes.
2500   if (!IMD)
2501     return false;
2502
2503   // method declared in interface has no attribute.
2504   // But implementation has attributes. This is invalid.
2505   // Except when implementation has 'Align' attribute which is
2506   // immaterial to method declared in interface.
2507   if (!IMD->hasAttrs())
2508     return (A.size() > countAlignAttr(A));
2509
2510   const AttrVec &D = IMD->getAttrs();
2511
2512   unsigned countAlignOnImpl = countAlignAttr(A);
2513   if (!countAlignOnImpl && (A.size() != D.size()))
2514     return true;
2515   else if (countAlignOnImpl) {
2516     unsigned countAlignOnDecl = countAlignAttr(D);
2517     if (countAlignOnDecl && (A.size() != D.size()))
2518       return true;
2519     else if (!countAlignOnDecl &&
2520              ((A.size()-countAlignOnImpl) != D.size()))
2521       return true;
2522   }
2523
2524   // attributes on method declaration and definition must match exactly.
2525   // Note that we have at most a couple of attributes on methods, so this
2526   // n*n search is good enough.
2527   for (AttrVec::const_iterator i = A.begin(), e = A.end(); i != e; ++i) {
2528     if ((*i)->getKind() == attr::Aligned)
2529       continue;
2530     bool match = false;
2531     for (AttrVec::const_iterator i1 = D.begin(), e1 = D.end(); i1 != e1; ++i1) {
2532       if ((*i)->getKind() == (*i1)->getKind()) {
2533         match = true;
2534         break;
2535       }
2536     }
2537     if (!match)
2538       return true;
2539   }
2540
2541   return false;
2542 }
2543
2544 /// \brief Check whether the declared result type of the given Objective-C
2545 /// method declaration is compatible with the method's class.
2546 ///
2547 static Sema::ResultTypeCompatibilityKind
2548 CheckRelatedResultTypeCompatibility(Sema &S, ObjCMethodDecl *Method,
2549                                     ObjCInterfaceDecl *CurrentClass) {
2550   QualType ResultType = Method->getResultType();
2551
2552   // If an Objective-C method inherits its related result type, then its
2553   // declared result type must be compatible with its own class type. The
2554   // declared result type is compatible if:
2555   if (const ObjCObjectPointerType *ResultObjectType
2556                                 = ResultType->getAs<ObjCObjectPointerType>()) {
2557     //   - it is id or qualified id, or
2558     if (ResultObjectType->isObjCIdType() ||
2559         ResultObjectType->isObjCQualifiedIdType())
2560       return Sema::RTC_Compatible;
2561
2562     if (CurrentClass) {
2563       if (ObjCInterfaceDecl *ResultClass
2564                                       = ResultObjectType->getInterfaceDecl()) {
2565         //   - it is the same as the method's class type, or
2566         if (declaresSameEntity(CurrentClass, ResultClass))
2567           return Sema::RTC_Compatible;
2568
2569         //   - it is a superclass of the method's class type
2570         if (ResultClass->isSuperClassOf(CurrentClass))
2571           return Sema::RTC_Compatible;
2572       }
2573     } else {
2574       // Any Objective-C pointer type might be acceptable for a protocol
2575       // method; we just don't know.
2576       return Sema::RTC_Unknown;
2577     }
2578   }
2579
2580   return Sema::RTC_Incompatible;
2581 }
2582
2583 namespace {
2584 /// A helper class for searching for methods which a particular method
2585 /// overrides.
2586 class OverrideSearch {
2587 public:
2588   Sema &S;
2589   ObjCMethodDecl *Method;
2590   llvm::SmallPtrSet<ObjCMethodDecl*, 4> Overridden;
2591   bool Recursive;
2592
2593 public:
2594   OverrideSearch(Sema &S, ObjCMethodDecl *method) : S(S), Method(method) {
2595     Selector selector = method->getSelector();
2596
2597     // Bypass this search if we've never seen an instance/class method
2598     // with this selector before.
2599     Sema::GlobalMethodPool::iterator it = S.MethodPool.find(selector);
2600     if (it == S.MethodPool.end()) {
2601       if (!S.getExternalSource()) return;
2602       S.ReadMethodPool(selector);
2603
2604       it = S.MethodPool.find(selector);
2605       if (it == S.MethodPool.end())
2606         return;
2607     }
2608     ObjCMethodList &list =
2609       method->isInstanceMethod() ? it->second.first : it->second.second;
2610     if (!list.Method) return;
2611
2612     ObjCContainerDecl *container
2613       = cast<ObjCContainerDecl>(method->getDeclContext());
2614
2615     // Prevent the search from reaching this container again.  This is
2616     // important with categories, which override methods from the
2617     // interface and each other.
2618     if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(container)) {
2619       searchFromContainer(container);
2620       if (ObjCInterfaceDecl *Interface = Category->getClassInterface())
2621         searchFromContainer(Interface);
2622     } else {
2623       searchFromContainer(container);
2624     }
2625   }
2626
2627   typedef llvm::SmallPtrSet<ObjCMethodDecl*, 128>::iterator iterator;
2628   iterator begin() const { return Overridden.begin(); }
2629   iterator end() const { return Overridden.end(); }
2630
2631 private:
2632   void searchFromContainer(ObjCContainerDecl *container) {
2633     if (container->isInvalidDecl()) return;
2634
2635     switch (container->getDeclKind()) {
2636 #define OBJCCONTAINER(type, base) \
2637     case Decl::type: \
2638       searchFrom(cast<type##Decl>(container)); \
2639       break;
2640 #define ABSTRACT_DECL(expansion)
2641 #define DECL(type, base) \
2642     case Decl::type:
2643 #include "clang/AST/DeclNodes.inc"
2644       llvm_unreachable("not an ObjC container!");
2645     }
2646   }
2647
2648   void searchFrom(ObjCProtocolDecl *protocol) {
2649     if (!protocol->hasDefinition())
2650       return;
2651
2652     // A method in a protocol declaration overrides declarations from
2653     // referenced ("parent") protocols.
2654     search(protocol->getReferencedProtocols());
2655   }
2656
2657   void searchFrom(ObjCCategoryDecl *category) {
2658     // A method in a category declaration overrides declarations from
2659     // the main class and from protocols the category references.
2660     // The main class is handled in the constructor.
2661     search(category->getReferencedProtocols());
2662   }
2663
2664   void searchFrom(ObjCCategoryImplDecl *impl) {
2665     // A method in a category definition that has a category
2666     // declaration overrides declarations from the category
2667     // declaration.
2668     if (ObjCCategoryDecl *category = impl->getCategoryDecl()) {
2669       search(category);
2670       if (ObjCInterfaceDecl *Interface = category->getClassInterface())
2671         search(Interface);
2672
2673     // Otherwise it overrides declarations from the class.
2674     } else if (ObjCInterfaceDecl *Interface = impl->getClassInterface()) {
2675       search(Interface);
2676     }
2677   }
2678
2679   void searchFrom(ObjCInterfaceDecl *iface) {
2680     // A method in a class declaration overrides declarations from
2681     if (!iface->hasDefinition())
2682       return;
2683
2684     //   - categories,
2685     for (ObjCCategoryDecl *category = iface->getCategoryList();
2686            category; category = category->getNextClassCategory())
2687       search(category);
2688
2689     //   - the super class, and
2690     if (ObjCInterfaceDecl *super = iface->getSuperClass())
2691       search(super);
2692
2693     //   - any referenced protocols.
2694     search(iface->getReferencedProtocols());
2695   }
2696
2697   void searchFrom(ObjCImplementationDecl *impl) {
2698     // A method in a class implementation overrides declarations from
2699     // the class interface.
2700     if (ObjCInterfaceDecl *Interface = impl->getClassInterface())
2701       search(Interface);
2702   }
2703
2704
2705   void search(const ObjCProtocolList &protocols) {
2706     for (ObjCProtocolList::iterator i = protocols.begin(), e = protocols.end();
2707          i != e; ++i)
2708       search(*i);
2709   }
2710
2711   void search(ObjCContainerDecl *container) {
2712     // Check for a method in this container which matches this selector.
2713     ObjCMethodDecl *meth = container->getMethod(Method->getSelector(),
2714                                                 Method->isInstanceMethod());
2715
2716     // If we find one, record it and bail out.
2717     if (meth) {
2718       Overridden.insert(meth);
2719       return;
2720     }
2721
2722     // Otherwise, search for methods that a hypothetical method here
2723     // would have overridden.
2724
2725     // Note that we're now in a recursive case.
2726     Recursive = true;
2727
2728     searchFromContainer(container);
2729   }
2730 };
2731 }
2732
2733 void Sema::CheckObjCMethodOverrides(ObjCMethodDecl *ObjCMethod,
2734                                     ObjCInterfaceDecl *CurrentClass,
2735                                     ResultTypeCompatibilityKind RTC) {
2736   // Search for overridden methods and merge information down from them.
2737   OverrideSearch overrides(*this, ObjCMethod);
2738   // Keep track if the method overrides any method in the class's base classes,
2739   // its protocols, or its categories' protocols; we will keep that info
2740   // in the ObjCMethodDecl.
2741   // For this info, a method in an implementation is not considered as
2742   // overriding the same method in the interface or its categories.
2743   bool hasOverriddenMethodsInBaseOrProtocol = false;
2744   for (OverrideSearch::iterator
2745          i = overrides.begin(), e = overrides.end(); i != e; ++i) {
2746     ObjCMethodDecl *overridden = *i;
2747
2748     if (isa<ObjCProtocolDecl>(overridden->getDeclContext()) ||
2749         CurrentClass != overridden->getClassInterface() ||
2750         overridden->isOverriding())
2751       hasOverriddenMethodsInBaseOrProtocol = true;
2752
2753     // Propagate down the 'related result type' bit from overridden methods.
2754     if (RTC != Sema::RTC_Incompatible && overridden->hasRelatedResultType())
2755       ObjCMethod->SetRelatedResultType();
2756
2757     // Then merge the declarations.
2758     mergeObjCMethodDecls(ObjCMethod, overridden);
2759
2760     if (ObjCMethod->isImplicit() && overridden->isImplicit())
2761       continue; // Conflicting properties are detected elsewhere.
2762
2763     // Check for overriding methods
2764     if (isa<ObjCInterfaceDecl>(ObjCMethod->getDeclContext()) ||
2765         isa<ObjCImplementationDecl>(ObjCMethod->getDeclContext()))
2766       CheckConflictingOverridingMethod(ObjCMethod, overridden,
2767               isa<ObjCProtocolDecl>(overridden->getDeclContext()));
2768
2769     if (CurrentClass && overridden->getDeclContext() != CurrentClass &&
2770         isa<ObjCInterfaceDecl>(overridden->getDeclContext()) &&
2771         !overridden->isImplicit() /* not meant for properties */) {
2772       ObjCMethodDecl::param_iterator ParamI = ObjCMethod->param_begin(),
2773                                           E = ObjCMethod->param_end();
2774       ObjCMethodDecl::param_iterator PrevI = overridden->param_begin(),
2775                                      PrevE = overridden->param_end();
2776       for (; ParamI != E && PrevI != PrevE; ++ParamI, ++PrevI) {
2777         assert(PrevI != overridden->param_end() && "Param mismatch");
2778         QualType T1 = Context.getCanonicalType((*ParamI)->getType());
2779         QualType T2 = Context.getCanonicalType((*PrevI)->getType());
2780         // If type of argument of method in this class does not match its
2781         // respective argument type in the super class method, issue warning;
2782         if (!Context.typesAreCompatible(T1, T2)) {
2783           Diag((*ParamI)->getLocation(), diag::ext_typecheck_base_super)
2784             << T1 << T2;
2785           Diag(overridden->getLocation(), diag::note_previous_declaration);
2786           break;
2787         }
2788       }
2789     }
2790   }
2791
2792   ObjCMethod->setOverriding(hasOverriddenMethodsInBaseOrProtocol);
2793 }
2794
2795 Decl *Sema::ActOnMethodDeclaration(
2796     Scope *S,
2797     SourceLocation MethodLoc, SourceLocation EndLoc,
2798     tok::TokenKind MethodType,
2799     ObjCDeclSpec &ReturnQT, ParsedType ReturnType,
2800     ArrayRef<SourceLocation> SelectorLocs,
2801     Selector Sel,
2802     // optional arguments. The number of types/arguments is obtained
2803     // from the Sel.getNumArgs().
2804     ObjCArgInfo *ArgInfo,
2805     DeclaratorChunk::ParamInfo *CParamInfo, unsigned CNumArgs, // c-style args
2806     AttributeList *AttrList, tok::ObjCKeywordKind MethodDeclKind,
2807     bool isVariadic, bool MethodDefinition) {
2808   // Make sure we can establish a context for the method.
2809   if (!CurContext->isObjCContainer()) {
2810     Diag(MethodLoc, diag::error_missing_method_context);
2811     return 0;
2812   }
2813   ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
2814   Decl *ClassDecl = cast<Decl>(OCD);
2815   QualType resultDeclType;
2816
2817   bool HasRelatedResultType = false;
2818   TypeSourceInfo *ResultTInfo = 0;
2819   if (ReturnType) {
2820     resultDeclType = GetTypeFromParser(ReturnType, &ResultTInfo);
2821
2822     // Methods cannot return interface types. All ObjC objects are
2823     // passed by reference.
2824     if (resultDeclType->isObjCObjectType()) {
2825       Diag(MethodLoc, diag::err_object_cannot_be_passed_returned_by_value)
2826         << 0 << resultDeclType;
2827       return 0;
2828     }
2829
2830     HasRelatedResultType = (resultDeclType == Context.getObjCInstanceType());
2831   } else { // get the type for "id".
2832     resultDeclType = Context.getObjCIdType();
2833     Diag(MethodLoc, diag::warn_missing_method_return_type)
2834       << FixItHint::CreateInsertion(SelectorLocs.front(), "(id)");
2835   }
2836
2837   ObjCMethodDecl* ObjCMethod =
2838     ObjCMethodDecl::Create(Context, MethodLoc, EndLoc, Sel,
2839                            resultDeclType,
2840                            ResultTInfo,
2841                            CurContext,
2842                            MethodType == tok::minus, isVariadic,
2843                            /*isPropertyAccessor=*/false,
2844                            /*isImplicitlyDeclared=*/false, /*isDefined=*/false,
2845                            MethodDeclKind == tok::objc_optional
2846                              ? ObjCMethodDecl::Optional
2847                              : ObjCMethodDecl::Required,
2848                            HasRelatedResultType);
2849
2850   SmallVector<ParmVarDecl*, 16> Params;
2851
2852   for (unsigned i = 0, e = Sel.getNumArgs(); i != e; ++i) {
2853     QualType ArgType;
2854     TypeSourceInfo *DI;
2855
2856     if (ArgInfo[i].Type == 0) {
2857       ArgType = Context.getObjCIdType();
2858       DI = 0;
2859     } else {
2860       ArgType = GetTypeFromParser(ArgInfo[i].Type, &DI);
2861       // Perform the default array/function conversions (C99 6.7.5.3p[7,8]).
2862       ArgType = Context.getAdjustedParameterType(ArgType);
2863     }
2864
2865     LookupResult R(*this, ArgInfo[i].Name, ArgInfo[i].NameLoc,
2866                    LookupOrdinaryName, ForRedeclaration);
2867     LookupName(R, S);
2868     if (R.isSingleResult()) {
2869       NamedDecl *PrevDecl = R.getFoundDecl();
2870       if (S->isDeclScope(PrevDecl)) {
2871         Diag(ArgInfo[i].NameLoc,
2872              (MethodDefinition ? diag::warn_method_param_redefinition
2873                                : diag::warn_method_param_declaration))
2874           << ArgInfo[i].Name;
2875         Diag(PrevDecl->getLocation(),
2876              diag::note_previous_declaration);
2877       }
2878     }
2879
2880     SourceLocation StartLoc = DI
2881       ? DI->getTypeLoc().getBeginLoc()
2882       : ArgInfo[i].NameLoc;
2883
2884     ParmVarDecl* Param = CheckParameter(ObjCMethod, StartLoc,
2885                                         ArgInfo[i].NameLoc, ArgInfo[i].Name,
2886                                         ArgType, DI, SC_None, SC_None);
2887
2888     Param->setObjCMethodScopeInfo(i);
2889
2890     Param->setObjCDeclQualifier(
2891       CvtQTToAstBitMask(ArgInfo[i].DeclSpec.getObjCDeclQualifier()));
2892
2893     // Apply the attributes to the parameter.
2894     ProcessDeclAttributeList(TUScope, Param, ArgInfo[i].ArgAttrs);
2895
2896     if (Param->hasAttr<BlocksAttr>()) {
2897       Diag(Param->getLocation(), diag::err_block_on_nonlocal);
2898       Param->setInvalidDecl();
2899     }
2900     S->AddDecl(Param);
2901     IdResolver.AddDecl(Param);
2902
2903     Params.push_back(Param);
2904   }
2905
2906   for (unsigned i = 0, e = CNumArgs; i != e; ++i) {
2907     ParmVarDecl *Param = cast<ParmVarDecl>(CParamInfo[i].Param);
2908     QualType ArgType = Param->getType();
2909     if (ArgType.isNull())
2910       ArgType = Context.getObjCIdType();
2911     else
2912       // Perform the default array/function conversions (C99 6.7.5.3p[7,8]).
2913       ArgType = Context.getAdjustedParameterType(ArgType);
2914     if (ArgType->isObjCObjectType()) {
2915       Diag(Param->getLocation(),
2916            diag::err_object_cannot_be_passed_returned_by_value)
2917       << 1 << ArgType;
2918       Param->setInvalidDecl();
2919     }
2920     Param->setDeclContext(ObjCMethod);
2921
2922     Params.push_back(Param);
2923   }
2924
2925   ObjCMethod->setMethodParams(Context, Params, SelectorLocs);
2926   ObjCMethod->setObjCDeclQualifier(
2927     CvtQTToAstBitMask(ReturnQT.getObjCDeclQualifier()));
2928
2929   if (AttrList)
2930     ProcessDeclAttributeList(TUScope, ObjCMethod, AttrList);
2931
2932   // Add the method now.
2933   const ObjCMethodDecl *PrevMethod = 0;
2934   if (ObjCImplDecl *ImpDecl = dyn_cast<ObjCImplDecl>(ClassDecl)) {
2935     if (MethodType == tok::minus) {
2936       PrevMethod = ImpDecl->getInstanceMethod(Sel);
2937       ImpDecl->addInstanceMethod(ObjCMethod);
2938     } else {
2939       PrevMethod = ImpDecl->getClassMethod(Sel);
2940       ImpDecl->addClassMethod(ObjCMethod);
2941     }
2942
2943     ObjCMethodDecl *IMD = 0;
2944     if (ObjCInterfaceDecl *IDecl = ImpDecl->getClassInterface())
2945       IMD = IDecl->lookupMethod(ObjCMethod->getSelector(),
2946                                 ObjCMethod->isInstanceMethod());
2947     if (ObjCMethod->hasAttrs() &&
2948         containsInvalidMethodImplAttribute(IMD, ObjCMethod->getAttrs())) {
2949       SourceLocation MethodLoc = IMD->getLocation();
2950       if (!getSourceManager().isInSystemHeader(MethodLoc)) {
2951         Diag(EndLoc, diag::warn_attribute_method_def);
2952         Diag(MethodLoc, diag::note_method_declared_at)
2953           << ObjCMethod->getDeclName();
2954       }
2955     }
2956   } else {
2957     cast<DeclContext>(ClassDecl)->addDecl(ObjCMethod);
2958   }
2959
2960   if (PrevMethod) {
2961     // You can never have two method definitions with the same name.
2962     Diag(ObjCMethod->getLocation(), diag::err_duplicate_method_decl)
2963       << ObjCMethod->getDeclName();
2964     Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
2965   }
2966
2967   // If this Objective-C method does not have a related result type, but we
2968   // are allowed to infer related result types, try to do so based on the
2969   // method family.
2970   ObjCInterfaceDecl *CurrentClass = dyn_cast<ObjCInterfaceDecl>(ClassDecl);
2971   if (!CurrentClass) {
2972     if (ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(ClassDecl))
2973       CurrentClass = Cat->getClassInterface();
2974     else if (ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(ClassDecl))
2975       CurrentClass = Impl->getClassInterface();
2976     else if (ObjCCategoryImplDecl *CatImpl
2977                                    = dyn_cast<ObjCCategoryImplDecl>(ClassDecl))
2978       CurrentClass = CatImpl->getClassInterface();
2979   }
2980
2981   ResultTypeCompatibilityKind RTC
2982     = CheckRelatedResultTypeCompatibility(*this, ObjCMethod, CurrentClass);
2983
2984   CheckObjCMethodOverrides(ObjCMethod, CurrentClass, RTC);
2985
2986   bool ARCError = false;
2987   if (getLangOpts().ObjCAutoRefCount)
2988     ARCError = CheckARCMethodDecl(*this, ObjCMethod);
2989
2990   // Infer the related result type when possible.
2991   if (!ARCError && RTC == Sema::RTC_Compatible &&
2992       !ObjCMethod->hasRelatedResultType() &&
2993       LangOpts.ObjCInferRelatedResultType) {
2994     bool InferRelatedResultType = false;
2995     switch (ObjCMethod->getMethodFamily()) {
2996     case OMF_None:
2997     case OMF_copy:
2998     case OMF_dealloc:
2999     case OMF_finalize:
3000     case OMF_mutableCopy:
3001     case OMF_release:
3002     case OMF_retainCount:
3003     case OMF_performSelector:
3004       break;
3005
3006     case OMF_alloc:
3007     case OMF_new:
3008       InferRelatedResultType = ObjCMethod->isClassMethod();
3009       break;
3010
3011     case OMF_init:
3012     case OMF_autorelease:
3013     case OMF_retain:
3014     case OMF_self:
3015       InferRelatedResultType = ObjCMethod->isInstanceMethod();
3016       break;
3017     }
3018
3019     if (InferRelatedResultType)
3020       ObjCMethod->SetRelatedResultType();
3021   }
3022
3023   ActOnDocumentableDecl(ObjCMethod);
3024
3025   return ObjCMethod;
3026 }
3027
3028 bool Sema::CheckObjCDeclScope(Decl *D) {
3029   // Following is also an error. But it is caused by a missing @end
3030   // and diagnostic is issued elsewhere.
3031   if (isa<ObjCContainerDecl>(CurContext->getRedeclContext()))
3032     return false;
3033
3034   // If we switched context to translation unit while we are still lexically in
3035   // an objc container, it means the parser missed emitting an error.
3036   if (isa<TranslationUnitDecl>(getCurLexicalContext()->getRedeclContext()))
3037     return false;
3038
3039   Diag(D->getLocation(), diag::err_objc_decls_may_only_appear_in_global_scope);
3040   D->setInvalidDecl();
3041
3042   return true;
3043 }
3044
3045 /// Called whenever \@defs(ClassName) is encountered in the source.  Inserts the
3046 /// instance variables of ClassName into Decls.
3047 void Sema::ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart,
3048                      IdentifierInfo *ClassName,
3049                      SmallVectorImpl<Decl*> &Decls) {
3050   // Check that ClassName is a valid class
3051   ObjCInterfaceDecl *Class = getObjCInterfaceDecl(ClassName, DeclStart);
3052   if (!Class) {
3053     Diag(DeclStart, diag::err_undef_interface) << ClassName;
3054     return;
3055   }
3056   if (LangOpts.ObjCRuntime.isNonFragile()) {
3057     Diag(DeclStart, diag::err_atdef_nonfragile_interface);
3058     return;
3059   }
3060
3061   // Collect the instance variables
3062   SmallVector<const ObjCIvarDecl*, 32> Ivars;
3063   Context.DeepCollectObjCIvars(Class, true, Ivars);
3064   // For each ivar, create a fresh ObjCAtDefsFieldDecl.
3065   for (unsigned i = 0; i < Ivars.size(); i++) {
3066     const FieldDecl* ID = cast<FieldDecl>(Ivars[i]);
3067     RecordDecl *Record = dyn_cast<RecordDecl>(TagD);
3068     Decl *FD = ObjCAtDefsFieldDecl::Create(Context, Record,
3069                                            /*FIXME: StartL=*/ID->getLocation(),
3070                                            ID->getLocation(),
3071                                            ID->getIdentifier(), ID->getType(),
3072                                            ID->getBitWidth());
3073     Decls.push_back(FD);
3074   }
3075
3076   // Introduce all of these fields into the appropriate scope.
3077   for (SmallVectorImpl<Decl*>::iterator D = Decls.begin();
3078        D != Decls.end(); ++D) {
3079     FieldDecl *FD = cast<FieldDecl>(*D);
3080     if (getLangOpts().CPlusPlus)
3081       PushOnScopeChains(cast<FieldDecl>(FD), S);
3082     else if (RecordDecl *Record = dyn_cast<RecordDecl>(TagD))
3083       Record->addDecl(FD);
3084   }
3085 }
3086
3087 /// \brief Build a type-check a new Objective-C exception variable declaration.
3088 VarDecl *Sema::BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType T,
3089                                       SourceLocation StartLoc,
3090                                       SourceLocation IdLoc,
3091                                       IdentifierInfo *Id,
3092                                       bool Invalid) {
3093   // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
3094   // duration shall not be qualified by an address-space qualifier."
3095   // Since all parameters have automatic store duration, they can not have
3096   // an address space.
3097   if (T.getAddressSpace() != 0) {
3098     Diag(IdLoc, diag::err_arg_with_address_space);
3099     Invalid = true;
3100   }
3101
3102   // An @catch parameter must be an unqualified object pointer type;
3103   // FIXME: Recover from "NSObject foo" by inserting the * in "NSObject *foo"?
3104   if (Invalid) {
3105     // Don't do any further checking.
3106   } else if (T->isDependentType()) {
3107     // Okay: we don't know what this type will instantiate to.
3108   } else if (!T->isObjCObjectPointerType()) {
3109     Invalid = true;
3110     Diag(IdLoc ,diag::err_catch_param_not_objc_type);
3111   } else if (T->isObjCQualifiedIdType()) {
3112     Invalid = true;
3113     Diag(IdLoc, diag::err_illegal_qualifiers_on_catch_parm);
3114   }
3115
3116   VarDecl *New = VarDecl::Create(Context, CurContext, StartLoc, IdLoc, Id,
3117                                  T, TInfo, SC_None, SC_None);
3118   New->setExceptionVariable(true);
3119
3120   // In ARC, infer 'retaining' for variables of retainable type.
3121   if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(New))
3122     Invalid = true;
3123
3124   if (Invalid)
3125     New->setInvalidDecl();
3126   return New;
3127 }
3128
3129 Decl *Sema::ActOnObjCExceptionDecl(Scope *S, Declarator &D) {
3130   const DeclSpec &DS = D.getDeclSpec();
3131
3132   // We allow the "register" storage class on exception variables because
3133   // GCC did, but we drop it completely. Any other storage class is an error.
3134   if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
3135     Diag(DS.getStorageClassSpecLoc(), diag::warn_register_objc_catch_parm)
3136       << FixItHint::CreateRemoval(SourceRange(DS.getStorageClassSpecLoc()));
3137   } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
3138     Diag(DS.getStorageClassSpecLoc(), diag::err_storage_spec_on_catch_parm)
3139       << DS.getStorageClassSpec();
3140   }
3141   if (D.getDeclSpec().isThreadSpecified())
3142     Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
3143   D.getMutableDeclSpec().ClearStorageClassSpecs();
3144
3145   DiagnoseFunctionSpecifiers(D);
3146
3147   // Check that there are no default arguments inside the type of this
3148   // exception object (C++ only).
3149   if (getLangOpts().CPlusPlus)
3150     CheckExtraCXXDefaultArguments(D);
3151
3152   TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
3153   QualType ExceptionType = TInfo->getType();
3154
3155   VarDecl *New = BuildObjCExceptionDecl(TInfo, ExceptionType,
3156                                         D.getSourceRange().getBegin(),
3157                                         D.getIdentifierLoc(),
3158                                         D.getIdentifier(),
3159                                         D.isInvalidType());
3160
3161   // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
3162   if (D.getCXXScopeSpec().isSet()) {
3163     Diag(D.getIdentifierLoc(), diag::err_qualified_objc_catch_parm)
3164       << D.getCXXScopeSpec().getRange();
3165     New->setInvalidDecl();
3166   }
3167
3168   // Add the parameter declaration into this scope.
3169   S->AddDecl(New);
3170   if (D.getIdentifier())
3171     IdResolver.AddDecl(New);
3172
3173   ProcessDeclAttributes(S, New, D);
3174
3175   if (New->hasAttr<BlocksAttr>())
3176     Diag(New->getLocation(), diag::err_block_on_nonlocal);
3177   return New;
3178 }
3179
3180 /// CollectIvarsToConstructOrDestruct - Collect those ivars which require
3181 /// initialization.
3182 void Sema::CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI,
3183                                 SmallVectorImpl<ObjCIvarDecl*> &Ivars) {
3184   for (ObjCIvarDecl *Iv = OI->all_declared_ivar_begin(); Iv;
3185        Iv= Iv->getNextIvar()) {
3186     QualType QT = Context.getBaseElementType(Iv->getType());
3187     if (QT->isRecordType())
3188       Ivars.push_back(Iv);
3189   }
3190 }
3191
3192 void Sema::DiagnoseUseOfUnimplementedSelectors() {
3193   // Load referenced selectors from the external source.
3194   if (ExternalSource) {
3195     SmallVector<std::pair<Selector, SourceLocation>, 4> Sels;
3196     ExternalSource->ReadReferencedSelectors(Sels);
3197     for (unsigned I = 0, N = Sels.size(); I != N; ++I)
3198       ReferencedSelectors[Sels[I].first] = Sels[I].second;
3199   }
3200
3201   // Warning will be issued only when selector table is
3202   // generated (which means there is at lease one implementation
3203   // in the TU). This is to match gcc's behavior.
3204   if (ReferencedSelectors.empty() ||
3205       !Context.AnyObjCImplementation())
3206     return;
3207   for (llvm::DenseMap<Selector, SourceLocation>::iterator S =
3208         ReferencedSelectors.begin(),
3209        E = ReferencedSelectors.end(); S != E; ++S) {
3210     Selector Sel = (*S).first;
3211     if (!LookupImplementedMethodInGlobalPool(Sel))
3212       Diag((*S).second, diag::warn_unimplemented_selector) << Sel;
3213   }
3214   return;
3215 }