Remove tabs, and whitespace cleanups.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@81346 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 286 insertions, 288 deletions

diff --git a/lib/Sema/SemaDeclObjC.cpp b/lib/Sema/SemaDeclObjC.cpp
index 988680a981..5b52ba9c8c 100644
--- a/lib/Sema/SemaDeclObjC.cpp
+++ b/lib/Sema/SemaDeclObjC.cpp
@@ -28,7 +28,7 @@ bool Sema::DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *property,
     if (property->getType()->isObjCObjectPointerType())
       result = CheckAssignmentConstraints(GetterMethod->getResultType(), property->getType());
     if (result != Compatible) {
-      Diag(Loc, diag::warn_accessor_property_type_mismatch) 
+      Diag(Loc, diag::warn_accessor_property_type_mismatch)
         << property->getDeclName()
         << GetterMethod->getSelector();
       Diag(GetterMethod->getLocation(), diag::note_declared_at);
@@ -43,7 +43,7 @@ bool Sema::DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *property,
 void Sema::ActOnStartOfObjCMethodDef(Scope *FnBodyScope, DeclPtrTy D) {
   assert(getCurMethodDecl() == 0 && "Method parsing confused");
   ObjCMethodDecl *MDecl = dyn_cast_or_null<ObjCMethodDecl>(D.getAs<Decl>());
-  
+
   // If we don't have a valid method decl, simply return.
   if (!MDecl)
     return;
@@ -55,7 +55,7 @@ void Sema::ActOnStartOfObjCMethodDef(Scope *FnBodyScope, DeclPtrTy D) {
     AddInstanceMethodToGlobalPool(MDecl);
   else
     AddFactoryMethodToGlobalPool(MDecl);
-  
+
   // Allow all of Sema to see that we are entering a method definition.
   PushDeclContext(FnBodyScope, MDecl);
 
@@ -64,7 +64,7 @@ void Sema::ActOnStartOfObjCMethodDef(Scope *FnBodyScope, DeclPtrTy D) {
 
   // Insert the invisible arguments, self and _cmd!
   MDecl->createImplicitParams(Context, MDecl->getClassInterface());
-  
+
   PushOnScopeChains(MDecl->getSelfDecl(), FnBodyScope);
   PushOnScopeChains(MDecl->getCmdDecl(), FnBodyScope);
 
@@ -82,7 +82,7 @@ ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
                          const DeclPtrTy *ProtoRefs, unsigned NumProtoRefs,
                          SourceLocation EndProtoLoc, AttributeList *AttrList) {
   assert(ClassName && "Missing class identifier");
-  
+
   // Check for another declaration kind with the same name.
   NamedDecl *PrevDecl = LookupName(TUScope, ClassName, LookupOrdinaryName);
   if (PrevDecl && PrevDecl->isTemplateParameter()) {
@@ -96,7 +96,7 @@ ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
     Diag(ClassLoc, diag::err_redefinition_different_kind) << ClassName;
     Diag(PrevDecl->getLocation(), diag::note_previous_definition);
   }
-  
+
   ObjCInterfaceDecl* IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
   if (IDecl) {
     // Class already seen. Is it a forward declaration?
@@ -113,14 +113,14 @@ ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
       IDecl->setForwardDecl(false);
     }
   } else {
-    IDecl = ObjCInterfaceDecl::Create(Context, CurContext, AtInterfaceLoc, 
+    IDecl = ObjCInterfaceDecl::Create(Context, CurContext, AtInterfaceLoc,
                                       ClassName, ClassLoc);
     if (AttrList)
       ProcessDeclAttributeList(TUScope, IDecl, AttrList);
-  
+
     PushOnScopeChains(IDecl, TUScope);
   }
-  
+
   if (SuperName) {
     // Check if a different kind of symbol declared in this scope.
     PrevDecl = LookupName(TUScope, SuperName, LookupOrdinaryName);
@@ -129,13 +129,13 @@ ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
         << SuperName << ClassName << SourceRange(AtInterfaceLoc, ClassLoc);
       IDecl->setLocEnd(ClassLoc);
     } else {
-      ObjCInterfaceDecl *SuperClassDecl = 
+      ObjCInterfaceDecl *SuperClassDecl =
                                 dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
 
       // Diagnose classes that inherit from deprecated classes.
       if (SuperClassDecl)
         (void)DiagnoseUseOfDecl(SuperClassDecl, SuperLoc);
-    
+
       if (PrevDecl && SuperClassDecl == 0) {
         // The previous declaration was not a class decl. Check if we have a
         // typedef. If we do, get the underlying class type.
@@ -146,7 +146,7 @@ ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
               SuperClassDecl = dyn_cast<ObjCInterfaceDecl>(IDecl);
           }
         }
-      
+
         // This handles the following case:
         //
         // typedef int SuperClass;
@@ -157,7 +157,7 @@ ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
           Diag(PrevDecl->getLocation(), diag::note_previous_definition);
         }
       }
-  
+
       if (!dyn_cast_or_null<TypedefDecl>(PrevDecl)) {
         if (!SuperClassDecl)
           Diag(SuperLoc, diag::err_undef_superclass)
@@ -174,14 +174,14 @@ ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
   } else { // we have a root class.
     IDecl->setLocEnd(ClassLoc);
   }
-  
+
   /// Check then save referenced protocols.
   if (NumProtoRefs) {
     IDecl->setProtocolList((ObjCProtocolDecl**)ProtoRefs, NumProtoRefs,
                            Context);
     IDecl->setLocEnd(EndProtoLoc);
   }
-  
+
   CheckObjCDeclScope(IDecl);
   return DeclPtrTy::make(IDecl);
 }
@@ -189,7 +189,7 @@ ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
 /// ActOnCompatiblityAlias - this action is called after complete parsing of
 /// @compatibility_alias declaration. It sets up the alias relationships.
 Sema::DeclPtrTy Sema::ActOnCompatiblityAlias(SourceLocation AtLoc,
-                                             IdentifierInfo *AliasName, 
+                                             IdentifierInfo *AliasName,
                                              SourceLocation AliasLocation,
                                              IdentifierInfo *ClassName,
                                              SourceLocation ClassLocation) {
@@ -221,11 +221,11 @@ Sema::DeclPtrTy Sema::ActOnCompatiblityAlias(SourceLocation AtLoc,
       Diag(CDeclU->getLocation(), diag::note_previous_declaration);
     return DeclPtrTy();
   }
-  
+
   // Everything checked out, instantiate a new alias declaration AST.
-  ObjCCompatibleAliasDecl *AliasDecl = 
+  ObjCCompatibleAliasDecl *AliasDecl =
     ObjCCompatibleAliasDecl::Create(Context, CurContext, AtLoc, AliasName, CDecl);
-  
+
   if (!CheckObjCDeclScope(AliasDecl))
     PushOnScopeChains(AliasDecl, TUScope);
 
@@ -235,17 +235,16 @@ Sema::DeclPtrTy Sema::ActOnCompatiblityAlias(SourceLocation AtLoc,
 void Sema::CheckForwardProtocolDeclarationForCircularDependency(
   IdentifierInfo *PName,
   SourceLocation &Ploc, SourceLocation PrevLoc,
-  const ObjCList<ObjCProtocolDecl> &PList) 
-{
+  const ObjCList<ObjCProtocolDecl> &PList) {
   for (ObjCList<ObjCProtocolDecl>::iterator I = PList.begin(),
        E = PList.end(); I != E; ++I) {
-       
+
     if (ObjCProtocolDecl *PDecl = LookupProtocol((*I)->getIdentifier())) {
       if (PDecl->getIdentifier() == PName) {
         Diag(Ploc, diag::err_protocol_has_circular_dependency);
         Diag(PrevLoc, diag::note_previous_definition);
       }
-      CheckForwardProtocolDeclarationForCircularDependency(PName, Ploc, 
+      CheckForwardProtocolDeclarationForCircularDependency(PName, Ploc,
         PDecl->getLocation(), PDecl->getReferencedProtocols());
     }
   }
@@ -272,16 +271,16 @@ Sema::ActOnStartProtocolInterface(SourceLocation AtProtoInterfaceLoc,
       return DeclPtrTy::make(PDecl);
     }
     ObjCList<ObjCProtocolDecl> PList;
-    PList.set((ObjCProtocolDecl *const*)ProtoRefs, NumProtoRefs, Context); 
+    PList.set((ObjCProtocolDecl *const*)ProtoRefs, NumProtoRefs, Context);
     CheckForwardProtocolDeclarationForCircularDependency(
       ProtocolName, ProtocolLoc, PDecl->getLocation(), PList);
     PList.Destroy(Context);
-    
+
     // Make sure the cached decl gets a valid start location.
     PDecl->setLocation(AtProtoInterfaceLoc);
     PDecl->setForwardDecl(false);
   } else {
-    PDecl = ObjCProtocolDecl::Create(Context, CurContext, 
+    PDecl = ObjCProtocolDecl::Create(Context, CurContext,
                                      AtProtoInterfaceLoc,ProtocolName);
     PushOnScopeChains(PDecl, TUScope);
     PDecl->setForwardDecl(false);
@@ -293,8 +292,8 @@ Sema::ActOnStartProtocolInterface(SourceLocation AtProtoInterfaceLoc,
     PDecl->setProtocolList((ObjCProtocolDecl**)ProtoRefs, NumProtoRefs,Context);
     PDecl->setLocEnd(EndProtoLoc);
   }
-  
-  CheckObjCDeclScope(PDecl);  
+
+  CheckObjCDeclScope(PDecl);
   return DeclPtrTy::make(PDecl);
 }
 
@@ -313,7 +312,7 @@ Sema::FindProtocolDeclaration(bool WarnOnDeclarations,
         << ProtocolId[i].first;
       continue;
     }
-    
+
     (void)DiagnoseUseOfDecl(PDecl, ProtocolId[i].second);
 
     // If this is a forward declaration and we are supposed to warn in this
@@ -329,12 +328,12 @@ Sema::FindProtocolDeclaration(bool WarnOnDeclarations,
 /// attributes and types and warns on a variety of inconsistencies.
 ///
 void
-Sema::DiagnosePropertyMismatch(ObjCPropertyDecl *Property, 
+Sema::DiagnosePropertyMismatch(ObjCPropertyDecl *Property,
                                ObjCPropertyDecl *SuperProperty,
                                const IdentifierInfo *inheritedName) {
-  ObjCPropertyDecl::PropertyAttributeKind CAttr = 
+  ObjCPropertyDecl::PropertyAttributeKind CAttr =
   Property->getPropertyAttributes();
-  ObjCPropertyDecl::PropertyAttributeKind SAttr = 
+  ObjCPropertyDecl::PropertyAttributeKind SAttr =
   SuperProperty->getPropertyAttributes();
   if ((CAttr & ObjCPropertyDecl::OBJC_PR_readonly)
       && (SAttr & ObjCPropertyDecl::OBJC_PR_readwrite))
@@ -348,23 +347,23 @@ Sema::DiagnosePropertyMismatch(ObjCPropertyDecl *Property,
            != (SAttr & ObjCPropertyDecl::OBJC_PR_retain))
     Diag(Property->getLocation(), diag::warn_property_attribute)
       << Property->getDeclName() << "retain" << inheritedName;
-  
+
   if ((CAttr & ObjCPropertyDecl::OBJC_PR_nonatomic)
       != (SAttr & ObjCPropertyDecl::OBJC_PR_nonatomic))
     Diag(Property->getLocation(), diag::warn_property_attribute)
       << Property->getDeclName() << "atomic" << inheritedName;
   if (Property->getSetterName() != SuperProperty->getSetterName())
     Diag(Property->getLocation(), diag::warn_property_attribute)
-      << Property->getDeclName() << "setter" << inheritedName; 
+      << Property->getDeclName() << "setter" << inheritedName;
   if (Property->getGetterName() != SuperProperty->getGetterName())
     Diag(Property->getLocation(), diag::warn_property_attribute)
       << Property->getDeclName() << "getter" << inheritedName;
 
-  QualType LHSType = 
+  QualType LHSType =
     Context.getCanonicalType(SuperProperty->getType());
-  QualType RHSType = 
+  QualType RHSType =
     Context.getCanonicalType(Property->getType());
-    
+
   if (!Context.typesAreCompatible(LHSType, RHSType)) {
     // FIXME: Incorporate this test with typesAreCompatible.
     if (LHSType->isObjCQualifiedIdType() && RHSType->isObjCQualifiedIdType())
@@ -392,7 +391,7 @@ void Sema::ComparePropertiesInBaseAndSuper(ObjCInterfaceDecl *IDecl) {
          E = IDecl->prop_end(); I != E; ++I) {
       ObjCPropertyDecl *PDecl = (*I);
       if (SuperPDecl->getIdentifier() == PDecl->getIdentifier())
-          DiagnosePropertyMismatch(PDecl, SuperPDecl, 
+          DiagnosePropertyMismatch(PDecl, SuperPDecl,
                                    SDecl->getIdentifier());
     }
   }
@@ -455,7 +454,7 @@ void Sema::MergeProtocolPropertiesIntoClass(Decl *CDecl,
            E = MDecl->protocol_end(); P != E; ++P)
       // Merge properties of category (*P) into IDECL's
       MergeOneProtocolPropertiesIntoClass(CatDecl, *P);
-    
+
       // Go thru the list of protocols for this category and recursively merge
       // their properties into this class as well.
       for (ObjCCategoryDecl::protocol_iterator P = CatDecl->protocol_begin(),
@@ -475,7 +474,7 @@ void Sema::MergeProtocolPropertiesIntoClass(Decl *CDecl,
          E = MDecl->protocol_end(); P != E; ++P)
       // Merge properties of class (*P) into IDECL's
       MergeOneProtocolPropertiesIntoClass(IDecl, *P);
-    
+
     // Go thru the list of protocols for this class and recursively merge
     // their properties into this class as well.
     for (ObjCInterfaceDecl::protocol_iterator P = IDecl->protocol_begin(),
@@ -492,7 +491,7 @@ void Sema::MergeProtocolPropertiesIntoClass(Decl *CDecl,
 /// DiagnoseClassExtensionDupMethods - Check for duplicate declaration of
 /// a class method in its extension.
 ///
-void Sema::DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT, 
+void Sema::DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT,
                                             ObjCInterfaceDecl *ID) {
   if (!ID)
     return;  // Possibly due to previous error
@@ -525,12 +524,12 @@ Sema::ActOnForwardProtocolDeclaration(SourceLocation AtProtocolLoc,
                                       unsigned NumElts,
                                       AttributeList *attrList) {
   llvm::SmallVector<ObjCProtocolDecl*, 32> Protocols;
-  
+
   for (unsigned i = 0; i != NumElts; ++i) {
     IdentifierInfo *Ident = IdentList[i].first;
     ObjCProtocolDecl *PDecl = LookupProtocol(Ident);
     if (PDecl == 0) { // Not already seen?
-      PDecl = ObjCProtocolDecl::Create(Context, CurContext, 
+      PDecl = ObjCProtocolDecl::Create(Context, CurContext,
                                        IdentList[i].second, Ident);
       PushOnScopeChains(PDecl, TUScope);
     }
@@ -538,8 +537,8 @@ Sema::ActOnForwardProtocolDeclaration(SourceLocation AtProtocolLoc,
       ProcessDeclAttributeList(TUScope, PDecl, attrList);
     Protocols.push_back(PDecl);
   }
-  
-  ObjCForwardProtocolDecl *PDecl = 
+
+  ObjCForwardProtocolDecl *PDecl =
     ObjCForwardProtocolDecl::Create(Context, CurContext, AtProtocolLoc,
                                     &Protocols[0], Protocols.size());
   CurContext->addDecl(PDecl);
@@ -555,7 +554,7 @@ ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc,
                             const DeclPtrTy *ProtoRefs,
                             unsigned NumProtoRefs,
                             SourceLocation EndProtoLoc) {
-  ObjCCategoryDecl *CDecl = 
+  ObjCCategoryDecl *CDecl =
     ObjCCategoryDecl::Create(Context, CurContext, AtInterfaceLoc, CategoryName);
   // FIXME: PushOnScopeChains?
   CurContext->addDecl(CDecl);
@@ -569,7 +568,7 @@ ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc,
   }
 
   CDecl->setClassInterface(IDecl);
-  
+
   // If the interface is deprecated, warn about it.
   (void)DiagnoseUseOfDecl(IDecl, ClassLoc);
 
@@ -591,7 +590,7 @@ ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc,
     CDecl->setProtocolList((ObjCProtocolDecl**)ProtoRefs, NumProtoRefs,Context);
     CDecl->setLocEnd(EndProtoLoc);
   }
-  
+
   CheckObjCDeclScope(CDecl);
   return DeclPtrTy::make(CDecl);
 }
@@ -617,7 +616,7 @@ Sema::DeclPtrTy Sema::ActOnStartCategoryImplementation(
     }
   }
 
-  ObjCCategoryImplDecl *CDecl = 
+  ObjCCategoryImplDecl *CDecl =
     ObjCCategoryImplDecl::Create(Context, CurContext, AtCatImplLoc, CatName,
                                  IDecl);
   /// Check that class of this category is already completely declared.
@@ -637,7 +636,7 @@ Sema::DeclPtrTy Sema::ActOnStartCategoryImplementation(
     } else
       CatIDecl->setImplementation(CDecl);
   }
-  
+
   CheckObjCDeclScope(CDecl);
   return DeclPtrTy::make(CDecl);
 }
@@ -645,7 +644,7 @@ Sema::DeclPtrTy Sema::ActOnStartCategoryImplementation(
 Sema::DeclPtrTy Sema::ActOnStartClassImplementation(
                       SourceLocation AtClassImplLoc,
                       IdentifierInfo *ClassName, SourceLocation ClassLoc,
-                      IdentifierInfo *SuperClassname, 
+                      IdentifierInfo *SuperClassname,
                       SourceLocation SuperClassLoc) {
   ObjCInterfaceDecl* IDecl = 0;
   // Check for another declaration kind with the same name.
@@ -655,13 +654,13 @@ Sema::DeclPtrTy Sema::ActOnStartClassImplementation(
     Diag(PrevDecl->getLocation(), diag::note_previous_definition);
   }  else {
     // Is there an interface declaration of this class; if not, warn!
-    IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl); 
+    IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
     if (!IDecl || IDecl->isForwardDecl()) {
       Diag(ClassLoc, diag::warn_undef_interface) << ClassName;
       IDecl = 0;
     }
   }
-  
+
   // Check that super class name is valid class name
   ObjCInterfaceDecl* SDecl = 0;
   if (SuperClassname) {
@@ -672,7 +671,7 @@ Sema::DeclPtrTy Sema::ActOnStartClassImplementation(
         << SuperClassname;
       Diag(PrevDecl->getLocation(), diag::note_previous_definition);
     } else {
-      SDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl); 
+      SDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
       if (!SDecl)
         Diag(SuperClassLoc, diag::err_undef_superclass)
           << SuperClassname << ClassName;
@@ -685,14 +684,14 @@ Sema::DeclPtrTy Sema::ActOnStartClassImplementation(
       }
     }
   }
-  
+
   if (!IDecl) {
     // Legacy case of @implementation with no corresponding @interface.
     // Build, chain & install the interface decl into the identifier.
 
     // FIXME: Do we support attributes on the @implementation? If so we should
     // copy them over.
-    IDecl = ObjCInterfaceDecl::Create(Context, CurContext, AtClassImplLoc, 
+    IDecl = ObjCInterfaceDecl::Create(Context, CurContext, AtClassImplLoc,
                                       ClassName, ClassLoc, false, true);
     IDecl->setSuperClass(SDecl);
     IDecl->setLocEnd(ClassLoc);
@@ -704,14 +703,14 @@ Sema::DeclPtrTy Sema::ActOnStartClassImplementation(
     // declaration; the user cannot reopen it.
     IDecl->setForwardDecl(false);
   }
-  
-  ObjCImplementationDecl* IMPDecl = 
-    ObjCImplementationDecl::Create(Context, CurContext, AtClassImplLoc, 
+
+  ObjCImplementationDecl* IMPDecl =
+    ObjCImplementationDecl::Create(Context, CurContext, AtClassImplLoc,
                                    IDecl, SDecl);
-  
+
   if (CheckObjCDeclScope(IMPDecl))
     return DeclPtrTy::make(IMPDecl);
-  
+
   // Check that there is no duplicate implementation of this class.
   if (IDecl->getImplementation()) {
     // FIXME: Don't leak everything!
@@ -743,21 +742,21 @@ void Sema::CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
   // If implementation has empty ivar list, just return.
   if (numIvars == 0)
     return;
-  
+
   assert(ivars && "missing @implementation ivars");
-  
+
   // Check interface's Ivar list against those in the implementation.
   // names and types must match.
   //
   unsigned j = 0;
-  ObjCInterfaceDecl::ivar_iterator 
+  ObjCInterfaceDecl::ivar_iterator
     IVI = IDecl->ivar_begin(), IVE = IDecl->ivar_end();
   for (; numIvars > 0 && IVI != IVE; ++IVI) {
     ObjCIvarDecl* ImplIvar = ivars[j++];
     ObjCIvarDecl* ClsIvar = *IVI;
     assert (ImplIvar && "missing implementation ivar");
     assert (ClsIvar && "missing class ivar");
-    
+
     // First, make sure the types match.
     if (Context.getCanonicalType(ImplIvar->getType()) !=
         Context.getCanonicalType(ClsIvar->getType())) {
@@ -774,7 +773,7 @@ void Sema::CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
           << ImplIvar->getIdentifier();
         Diag(ClsBitWidth->getLocStart(), diag::note_previous_definition);
       }
-    } 
+    }
     // Make sure the names are identical.
     if (ImplIvar->getIdentifier() != ClsIvar->getIdentifier()) {
       Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_name)
@@ -783,7 +782,7 @@ void Sema::CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
     }
     --numIvars;
   }
-  
+
   if (numIvars > 0)
     Diag(ivars[j]->getLocation(), diag::err_inconsistant_ivar_count);
   else if (IVI != IVE)
@@ -805,21 +804,21 @@ void Sema::WarnConflictingTypedMethods(ObjCMethodDecl *ImpMethodDecl,
                                   ImpMethodDecl->getResultType()) &&
       !Context.QualifiedIdConformsQualifiedId(IntfMethodDecl->getResultType(),
                                               ImpMethodDecl->getResultType())) {
-    Diag(ImpMethodDecl->getLocation(), diag::warn_conflicting_ret_types) 
+    Diag(ImpMethodDecl->getLocation(), diag::warn_conflicting_ret_types)
       << ImpMethodDecl->getDeclName() << IntfMethodDecl->getResultType()
       << ImpMethodDecl->getResultType();
     Diag(IntfMethodDecl->getLocation(), diag::note_previous_definition);
   }
-  
+
   for (ObjCMethodDecl::param_iterator IM = ImpMethodDecl->param_begin(),
        IF = IntfMethodDecl->param_begin(), EM = ImpMethodDecl->param_end();
        IM != EM; ++IM, ++IF) {
     if (Context.typesAreCompatible((*IF)->getType(), (*IM)->getType()) ||
-        Context.QualifiedIdConformsQualifiedId((*IF)->getType(), 
+        Context.QualifiedIdConformsQualifiedId((*IF)->getType(),
                                                (*IM)->getType()))
       continue;
-    
-    Diag((*IM)->getLocation(), diag::warn_conflicting_param_types) 
+
+    Diag((*IM)->getLocation(), diag::warn_conflicting_param_types)
       << ImpMethodDecl->getDeclName() << (*IF)->getType()
       << (*IM)->getType();
     Diag((*IF)->getLocation(), diag::note_previous_definition);
@@ -834,34 +833,34 @@ bool Sema::isPropertyReadonly(ObjCPropertyDecl *PDecl,
   // by far the most common case.
   if (!PDecl->isReadOnly())
     return false;
-  // Even if property is ready only, if interface has a user defined setter, 
+  // Even if property is ready only, if interface has a user defined setter,
   // it is not considered read only.
   if (IDecl->getInstanceMethod(PDecl->getSetterName()))
     return false;
-  
+
   // Main class has the property as 'readonly'. Must search
-  // through the category list to see if the property's 
+  // through the category list to see if the property's
   // attribute has been over-ridden to 'readwrite'.
   for (ObjCCategoryDecl *Category = IDecl->getCategoryList();
        Category; Category = Category->getNextClassCategory()) {
-    // Even if property is ready only, if a category has a user defined setter, 
-    // it is not considered read only. 
+    // Even if property is ready only, if a category has a user defined setter,
+    // it is not considered read only.
     if (Category->getInstanceMethod(PDecl->getSetterName()))
       return false;
-    ObjCPropertyDecl *P = 
+    ObjCPropertyDecl *P =
       Category->FindPropertyDeclaration(PDecl->getIdentifier());
     if (P && !P->isReadOnly())
       return false;
   }
-  
+
   // Also, check for definition of a setter method in the implementation if
   // all else failed.
   if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(CurContext)) {
-    if (ObjCImplementationDecl *IMD = 
+    if (ObjCImplementationDecl *IMD =
         dyn_cast<ObjCImplementationDecl>(OMD->getDeclContext())) {
       if (IMD->getInstanceMethod(PDecl->getSetterName()))
         return false;
-    } else if (ObjCCategoryImplDecl *CIMD = 
+    } else if (ObjCCategoryImplDecl *CIMD =
                dyn_cast<ObjCCategoryImplDecl>(OMD->getDeclContext())) {
       if (CIMD->getInstanceMethod(PDecl->getSetterName()))
         return false;
@@ -894,11 +893,11 @@ void Sema::CheckProtocolMethodDefs(SourceLocation ImpLoc,
   ObjCInterfaceDecl *Super = IDecl->getSuperClass();
   ObjCInterfaceDecl *NSIDecl = 0;
   if (getLangOptions().NeXTRuntime) {
-    // check to see if class implements forwardInvocation method and objects 
-    // of this class are derived from 'NSProxy' so that to forward requests 
+    // check to see if class implements forwardInvocation method and objects
+    // of this class are derived from 'NSProxy' so that to forward requests
     // from one object to another.
-    // Under such conditions, which means that every method possible is 
-    // implemented in the class, we should not issue "Method definition not 
+    // Under such conditions, which means that every method possible is
+    // implemented in the class, we should not issue "Method definition not
     // found" warnings.
     // FIXME: Use a general GetUnarySelector method for this.
     IdentifierInfo* II = &Context.Idents.get("forwardInvocation");
@@ -908,7 +907,7 @@ void Sema::CheckProtocolMethodDefs(SourceLocation ImpLoc,
       // need be implemented in the implementation.
       NSIDecl = IDecl->lookupInheritedClass(&Context.Idents.get("NSProxy"));
   }
-  
+
   // If a method lookup fails locally we still need to look and see if
   // the method was implemented by a base class or an inherited
   // protocol. This lookup is slow, but occurs rarely in correct code
@@ -916,24 +915,24 @@ void Sema::CheckProtocolMethodDefs(SourceLocation ImpLoc,
 
   // check unimplemented instance methods.
   if (!NSIDecl)
-    for (ObjCProtocolDecl::instmeth_iterator I = PDecl->instmeth_begin(), 
+    for (ObjCProtocolDecl::instmeth_iterator I = PDecl->instmeth_begin(),
          E = PDecl->instmeth_end(); I != E; ++I) {
       ObjCMethodDecl *method = *I;
-      if (method->getImplementationControl() != ObjCMethodDecl::Optional && 
+      if (method->getImplementationControl() != ObjCMethodDecl::Optional &&
           !method->isSynthesized() && !InsMap.count(method->getSelector()) &&
-          (!Super || 
+          (!Super ||
            !Super->lookupInstanceMethod(method->getSelector()))) {
             // Ugly, but necessary. Method declared in protcol might have
             // have been synthesized due to a property declared in the class which
             // uses the protocol.
-            ObjCMethodDecl *MethodInClass = 
+            ObjCMethodDecl *MethodInClass =
             IDecl->lookupInstanceMethod(method->getSelector());
             if (!MethodInClass || !MethodInClass->isSynthesized())
               WarnUndefinedMethod(ImpLoc, method, IncompleteImpl);
           }
     }
   // check unimplemented class methods
-  for (ObjCProtocolDecl::classmeth_iterator 
+  for (ObjCProtocolDecl::classmeth_iterator
          I = PDecl->classmeth_begin(), E = PDecl->classmeth_end();
        I != E; ++I) {
     ObjCMethodDecl *method = *I;
@@ -958,8 +957,7 @@ void Sema::MatchAllMethodDeclarations(const llvm::DenseSet<Selector> &InsMap,
                                       ObjCImplDecl* IMPDecl,
                                       ObjCContainerDecl* CDecl,
                                       bool &IncompleteImpl,
-                                      bool ImmediateClass)
-{
+                                      bool ImmediateClass) {
   // Check and see if instance methods in class interface have been
   // implemented in the implementation class. If so, their types match.
   for (ObjCInterfaceDecl::instmeth_iterator I = CDecl->instmeth_begin(),
@@ -967,27 +965,27 @@ void Sema::MatchAllMethodDeclarations(const llvm::DenseSet<Selector> &InsMap,
     if (InsMapSeen.count((*I)->getSelector()))
         continue;
     InsMapSeen.insert((*I)->getSelector());
-    if (!(*I)->isSynthesized() && 
+    if (!(*I)->isSynthesized() &&
         !InsMap.count((*I)->getSelector())) {
       if (ImmediateClass)
         WarnUndefinedMethod(IMPDecl->getLocation(), *I, IncompleteImpl);
       continue;
     } else {
-      ObjCMethodDecl *ImpMethodDecl = 
+      ObjCMethodDecl *ImpMethodDecl =
       IMPDecl->getInstanceMethod((*I)->getSelector());
-      ObjCMethodDecl *IntfMethodDecl = 
+      ObjCMethodDecl *IntfMethodDecl =
       CDecl->getInstanceMethod((*I)->getSelector());
-      assert(IntfMethodDecl && 
+      assert(IntfMethodDecl &&
              "IntfMethodDecl is null in ImplMethodsVsClassMethods");
       // ImpMethodDecl may be null as in a @dynamic property.
       if (ImpMethodDecl)
         WarnConflictingTypedMethods(ImpMethodDecl, IntfMethodDecl);
     }
   }
-  
+
   // Check and see if class methods in class interface have been
   // implemented in the implementation class. If so, their types match.
-   for (ObjCInterfaceDecl::classmeth_iterator 
+   for (ObjCInterfaceDecl::classmeth_iterator
        I = CDecl->classmeth_begin(), E = CDecl->classmeth_end(); I != E; ++I) {
      if (ClsMapSeen.count((*I)->getSelector()))
        continue;
@@ -998,7 +996,7 @@ void Sema::MatchAllMethodDeclarations(const llvm::DenseSet<Selector> &InsMap,
     } else {
       ObjCMethodDecl *ImpMethodDecl =
         IMPDecl->getClassMethod((*I)->getSelector());
-      ObjCMethodDecl *IntfMethodDecl = 
+      ObjCMethodDecl *IntfMethodDecl =
         CDecl->getClassMethod((*I)->getSelector());
       WarnConflictingTypedMethods(ImpMethodDecl, IntfMethodDecl);
     }
@@ -1007,26 +1005,26 @@ void Sema::MatchAllMethodDeclarations(const llvm::DenseSet<Selector> &InsMap,
     // Check for any implementation of a methods declared in protocol.
     for (ObjCInterfaceDecl::protocol_iterator PI = I->protocol_begin(),
          E = I->protocol_end(); PI != E; ++PI)
-      MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen, 
-                                 IMPDecl, 
+      MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
+                                 IMPDecl,
                                  (*PI), IncompleteImpl, false);
     if (I->getSuperClass())
       MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
-                                 IMPDecl, 
+                                 IMPDecl,
                                  I->getSuperClass(), IncompleteImpl, false);
   }
 }
 
-void Sema::ImplMethodsVsClassMethods(ObjCImplDecl* IMPDecl, 
-                                     ObjCContainerDecl* CDecl, 
+void Sema::ImplMethodsVsClassMethods(ObjCImplDecl* IMPDecl,
+                                     ObjCContainerDecl* CDecl,
                                      bool IncompleteImpl) {
   llvm::DenseSet<Selector> InsMap;
   // Check and see if instance methods in class interface have been
   // implemented in the implementation class.
-  for (ObjCImplementationDecl::instmeth_iterator 
+  for (ObjCImplementationDecl::instmeth_iterator
          I = IMPDecl->instmeth_begin(), E = IMPDecl->instmeth_end(); I!=E; ++I)
     InsMap.insert((*I)->getSelector());
-  
+
   // Check and see if properties declared in the interface have either 1)
   // an implementation or 2) there is a @synthesize/@dynamic implementation
   // of the property in the @implementation.
@@ -1038,7 +1036,7 @@ void Sema::ImplMethodsVsClassMethods(ObjCImplDecl* IMPDecl,
           continue;
         ObjCPropertyImplDecl *PI = 0;
         // Is there a matching propery synthesize/dynamic?
-        for (ObjCImplDecl::propimpl_iterator 
+        for (ObjCImplDecl::propimpl_iterator
                I = IMPDecl->propimpl_begin(),
                EI = IMPDecl->propimpl_end(); I != EI; ++I)
           if ((*I)->getPropertyDecl() == Prop) {
@@ -1048,44 +1046,44 @@ void Sema::ImplMethodsVsClassMethods(ObjCImplDecl* IMPDecl,
         if (PI)
           continue;
         if (!InsMap.count(Prop->getGetterName())) {
-          Diag(Prop->getLocation(), 
-               diag::warn_setter_getter_impl_required) 
+          Diag(Prop->getLocation(),
+               diag::warn_setter_getter_impl_required)
           << Prop->getDeclName() << Prop->getGetterName();
           Diag(IMPDecl->getLocation(),
                diag::note_property_impl_required);
         }
-    
+
         if (!Prop->isReadOnly() && !InsMap.count(Prop->getSetterName())) {
-          Diag(Prop->getLocation(), 
-               diag::warn_setter_getter_impl_required) 
+          Diag(Prop->getLocation(),
+               diag::warn_setter_getter_impl_required)
           << Prop->getDeclName() << Prop->getSetterName();
           Diag(IMPDecl->getLocation(),
                diag::note_property_impl_required);
         }
       }
-  
+
   llvm::DenseSet<Selector> ClsMap;
-  for (ObjCImplementationDecl::classmeth_iterator 
+  for (ObjCImplementationDecl::classmeth_iterator
        I = IMPDecl->classmeth_begin(),
        E = IMPDecl->classmeth_end(); I != E; ++I)
     ClsMap.insert((*I)->getSelector());
-  
+
   // Check for type conflict of methods declared in a class/protocol and
   // its implementation; if any.
   llvm::DenseSet<Selector> InsMapSeen, ClsMapSeen;
-  MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen, 
-                             IMPDecl, CDecl, 
+  MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
+                             IMPDecl, CDecl,
                              IncompleteImpl, true);
-  
+
   // Check the protocol list for unimplemented methods in the @implementation
   // class.
   // Check and see if class methods in class interface have been
   // implemented in the implementation class.
-  
+
   if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl> (CDecl)) {
     for (ObjCInterfaceDecl::protocol_iterator PI = I->protocol_begin(),
          E = I->protocol_end(); PI != E; ++PI)
-      CheckProtocolMethodDefs(IMPDecl->getLocation(), *PI, IncompleteImpl, 
+      CheckProtocolMethodDefs(IMPDecl->getLocation(), *PI, IncompleteImpl,
                               InsMap, ClsMap, I);
     // Check class extensions (unnamed categories)
     for (ObjCCategoryDecl *Categories = I->getCategoryList();
@@ -1098,19 +1096,19 @@ void Sema::ImplMethodsVsClassMethods(ObjCImplDecl* IMPDecl,
   } else if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(CDecl)) {
     for (ObjCCategoryDecl::protocol_iterator PI = C->protocol_begin(),
          E = C->protocol_end(); PI != E; ++PI)
-      CheckProtocolMethodDefs(IMPDecl->getLocation(), *PI, IncompleteImpl, 
+      CheckProtocolMethodDefs(IMPDecl->getLocation(), *PI, IncompleteImpl,
                               InsMap, ClsMap, C->getClassInterface());
   } else
     assert(false && "invalid ObjCContainerDecl type.");
 }
 
-/// ActOnForwardClassDeclaration - 
+/// ActOnForwardClassDeclaration -
 Action::DeclPtrTy
 Sema::ActOnForwardClassDeclaration(SourceLocation AtClassLoc,
                                    IdentifierInfo **IdentList,
                                    unsigned NumElts) {
   llvm::SmallVector<ObjCInterfaceDecl*, 32> Interfaces;
-  
+
   for (unsigned i = 0; i != NumElts; ++i) {
     // Check for another declaration kind with the same name.
     NamedDecl *PrevDecl = LookupName(TUScope, IdentList[i], LookupOrdinaryName);
@@ -1127,7 +1125,7 @@ Sema::ActOnForwardClassDeclaration(SourceLocation AtClassLoc,
       // typedef NSObject < XCElementTogglerP > XCElementToggler;
       // @class XCElementToggler;
       //
-      // FIXME: Make an extension? 
+      // FIXME: Make an extension?
       TypedefDecl *TDD = dyn_cast<TypedefDecl>(PrevDecl);
       if (!TDD || !isa<ObjCInterfaceType>(TDD->getUnderlyingType())) {
         Diag(AtClassLoc, diag::err_redefinition_different_kind) << IdentList[i];
@@ -1135,21 +1133,21 @@ Sema::ActOnForwardClassDeclaration(SourceLocation AtClassLoc,
       } else if (TDD) {
         // a forward class declaration matching a typedef name of a class refers
         // to the underlying class.
-        if (ObjCInterfaceType * OI = 
+        if (ObjCInterfaceType * OI =
               dyn_cast<ObjCInterfaceType>(TDD->getUnderlyingType()))
           PrevDecl = OI->getDecl();
       }
     }
-    ObjCInterfaceDecl *IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl); 
+    ObjCInterfaceDecl *IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
     if (!IDecl) {  // Not already seen?  Make a forward decl.
-      IDecl = ObjCInterfaceDecl::Create(Context, CurContext, AtClassLoc, 
+      IDecl = ObjCInterfaceDecl::Create(Context, CurContext, AtClassLoc,
                                         IdentList[i], SourceLocation(), true);
       PushOnScopeChains(IDecl, TUScope);
     }
 
     Interfaces.push_back(IDecl);
   }
-  
+
   ObjCClassDecl *CDecl = ObjCClassDecl::Create(Context, CurContext, AtClassLoc,
                                                &Interfaces[0],
                                                Interfaces.size());
@@ -1162,12 +1160,12 @@ Sema::ActOnForwardClassDeclaration(SourceLocation AtClassLoc,
 /// MatchTwoMethodDeclarations - Checks that two methods have matching type and
 /// returns true, or false, accordingly.
 /// TODO: Handle protocol list; such as id<p1,p2> in type comparisons
-bool Sema::MatchTwoMethodDeclarations(const ObjCMethodDecl *Method, 
+bool Sema::MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,
                                       const ObjCMethodDecl *PrevMethod,
                                       bool matchBasedOnSizeAndAlignment) {
   QualType T1 = Context.getCanonicalType(Method->getResultType());
   QualType T2 = Context.getCanonicalType(PrevMethod->getResultType());
-  
+
   if (T1 != T2) {
     // The result types are different.
     if (!matchBasedOnSizeAndAlignment)
@@ -1179,11 +1177,11 @@ bool Sema::MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,
     if (Context.getTypeInfo(T1) != Context.getTypeInfo(T2))
       return false;
   }
-  
+
   ObjCMethodDecl::param_iterator ParamI = Method->param_begin(),
        E = Method->param_end();
   ObjCMethodDecl::param_iterator PrevI = PrevMethod->param_begin();
-  
+
   for (; ParamI != E; ++ParamI, ++PrevI) {
     assert(PrevI != PrevMethod->param_end() && "Param mismatch");
     T1 = Context.getCanonicalType((*ParamI)->getType());
@@ -1208,7 +1206,7 @@ bool Sema::MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,
 ///
 /// This routine should only be called once, when neither the instance
 /// nor the factory method pool has an entry for this selector.
-Sema::MethodPool::iterator Sema::ReadMethodPool(Selector Sel, 
+Sema::MethodPool::iterator Sema::ReadMethodPool(Selector Sel,
                                                 bool isInstance) {
   assert(ExternalSource && "We need an external AST source");
   assert(InstanceMethodPool.find(Sel) == InstanceMethodPool.end() &&
@@ -1219,12 +1217,12 @@ Sema::MethodPool::iterator Sema::ReadMethodPool(Selector Sel,
   // Read the method list from the external source.
   std::pair<ObjCMethodList, ObjCMethodList> Methods
     = ExternalSource->ReadMethodPool(Sel);
-  
+
   if (isInstance) {
     if (Methods.second.Method)
       FactoryMethodPool[Sel] = Methods.second;
     return InstanceMethodPool.inse