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, 363 insertions, 380 deletions

diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp
index 1427d48bc2..c5bbd34af8 100644
--- a/lib/Sema/SemaOverload.cpp
+++ b/lib/Sema/SemaOverload.cpp
@@ -30,7 +30,7 @@ namespace clang {
 
 /// GetConversionCategory - Retrieve the implicit conversion
 /// category corresponding to the given implicit conversion kind.
-ImplicitConversionCategory 
+ImplicitConversionCategory
 GetConversionCategory(ImplicitConversionKind Kind) {
   static const ImplicitConversionCategory
     Category[(int)ICK_Num_Conversion_Kinds] = {
@@ -138,10 +138,9 @@ ImplicitConversionRank StandardConversionSequence::getRank() const {
 
 /// isPointerConversionToBool - Determines whether this conversion is
 /// a conversion of a pointer or pointer-to-member to bool. This is
-/// used as part of the ranking of standard conversion sequences 
+/// used as part of the ranking of standard conversion sequences
 /// (C++ 13.3.3.2p4).
-bool StandardConversionSequence::isPointerConversionToBool() const
-{
+bool StandardConversionSequence::isPointerConversionToBool() const {
   QualType FromType = QualType::getFromOpaquePtr(FromTypePtr);
   QualType ToType = QualType::getFromOpaquePtr(ToTypePtr);
 
@@ -161,10 +160,9 @@ bool StandardConversionSequence::isPointerConversionToBool() const
 /// conversion is a conversion of a pointer to a void pointer. This is
 /// used as part of the ranking of standard conversion sequences (C++
 /// 13.3.3.2p4).
-bool 
+bool
 StandardConversionSequence::
-isPointerConversionToVoidPointer(ASTContext& Context) const
-{
+isPointerConversionToVoidPointer(ASTContext& Context) const {
   QualType FromType = QualType::getFromOpaquePtr(FromTypePtr);
   QualType ToType = QualType::getFromOpaquePtr(ToTypePtr);
 
@@ -262,7 +260,7 @@ void ImplicitConversionSequence::DebugPrint() const {
 // same signature (C++ 1.3.10) or if the Old declaration isn't a
 // function (or overload set). When it does return false and Old is an
 // OverloadedFunctionDecl, MatchedDecl will be set to point to the
-// FunctionDecl that New cannot be overloaded with. 
+// FunctionDecl that New cannot be overloaded with.
 //
 // Example: Given the following input:
 //
@@ -271,7 +269,7 @@ void ImplicitConversionSequence::DebugPrint() const {
 //   int f(int, int); // #3
 //
 // When we process #1, there is no previous declaration of "f",
-// so IsOverload will not be used. 
+// so IsOverload will not be used.
 //
 // When we process #2, Old is a FunctionDecl for #1.  By comparing the
 // parameter types, we see that #1 and #2 are overloaded (since they
@@ -285,9 +283,8 @@ void ImplicitConversionSequence::DebugPrint() const {
 // signature), IsOverload returns false and MatchedDecl will be set to
 // point to the FunctionDecl for #2.
 bool
-Sema::IsOverload(FunctionDecl *New, Decl* OldD, 
-                 OverloadedFunctionDecl::function_iterator& MatchedDecl)
-{
+Sema::IsOverload(FunctionDecl *New, Decl* OldD,
+                 OverloadedFunctionDecl::function_iterator& MatchedDecl) {
   if (OverloadedFunctionDecl* Ovl = dyn_cast<OverloadedFunctionDecl>(OldD)) {
     // Is this new function an overload of every function in the
     // overload set?
@@ -306,8 +303,8 @@ Sema::IsOverload(FunctionDecl *New, Decl* OldD,
     return IsOverload(New, Old->getTemplatedDecl(), MatchedDecl);
   else if (FunctionDecl* Old = dyn_cast<FunctionDecl>(OldD)) {
     FunctionTemplateDecl *OldTemplate = Old->getDescribedFunctionTemplate();
-    FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate(); 
-    
+    FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate();
+
     // C++ [temp.fct]p2:
     //   A function template can be overloaded with other function templates
     //   and with normal (non-template) functions.
@@ -342,21 +339,21 @@ Sema::IsOverload(FunctionDecl *New, Decl* OldD,
       return true;
 
     // C++ [temp.over.link]p4:
-    //   The signature of a function template consists of its function 
+    //   The signature of a function template consists of its function
     //   signature, its return type and its template parameter list. The names
     //   of the template parameters are significant only for establishing the
-    //   relationship between the template parameters and the rest of the 
+    //   relationship between the template parameters and the rest of the
     //   signature.
     //
     // We check the return type and template parameter lists for function
     // templates first; the remaining checks follow.
     if (NewTemplate &&
-        (!TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(), 
-                                         OldTemplate->getTemplateParameters(), 
+        (!TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
+                                         OldTemplate->getTemplateParameters(),
                                          false, false, SourceLocation()) ||
          OldType->getResultType() != NewType->getResultType()))
       return true;
-    
+
     // If the function is a class member, its signature includes the
     // cv-qualifiers (if any) on the function itself.
     //
@@ -367,7 +364,7 @@ Sema::IsOverload(FunctionDecl *New, Decl* OldD,
     // can be overloaded.
     CXXMethodDecl* OldMethod = dyn_cast<CXXMethodDecl>(Old);
     CXXMethodDecl* NewMethod = dyn_cast<CXXMethodDecl>(New);
-    if (OldMethod && NewMethod && 
+    if (OldMethod && NewMethod &&
         !OldMethod->isStatic() && !NewMethod->isStatic() &&
         OldMethod->getTypeQualifiers() != NewMethod->getTypeQualifiers())
       return true;
@@ -411,13 +408,12 @@ ImplicitConversionSequence
 Sema::TryImplicitConversion(Expr* From, QualType ToType,
                             bool SuppressUserConversions,
                             bool AllowExplicit, bool ForceRValue,
-                            bool InOverloadResolution)
-{
+                            bool InOverloadResolution) {
   ImplicitConversionSequence ICS;
   if (IsStandardConversion(From, ToType, InOverloadResolution, ICS.Standard))
     ICS.ConversionKind = ImplicitConversionSequence::StandardConversion;
   else if (getLangOptions().CPlusPlus &&
-           IsUserDefinedConversion(From, ToType, ICS.UserDefined, 
+           IsUserDefinedConversion(From, ToType, ICS.UserDefined,
                                    !SuppressUserConversions, AllowExplicit,
                                    ForceRValue)) {
     ICS.ConversionKind = ImplicitConversionSequence::UserDefinedConversion;
@@ -428,9 +424,9 @@ Sema::TryImplicitConversion(Expr* From, QualType ToType,
     //   given Conversion rank, in spite of the fact that a copy
     //   constructor (i.e., a user-defined conversion function) is
     //   called for those cases.
-    if (CXXConstructorDecl *Constructor 
+    if (CXXConstructorDecl *Constructor
           = dyn_cast<CXXConstructorDecl>(ICS.UserDefined.ConversionFunction)) {
-      QualType FromCanon 
+      QualType FromCanon
         = Context.getCanonicalType(From->getType().getUnqualifiedType());
       QualType ToCanon = Context.getCanonicalType(ToType).getUnqualifiedType();
       if (FromCanon == ToCanon || IsDerivedFrom(FromCanon, ToCanon)) {
@@ -470,11 +466,10 @@ Sema::TryImplicitConversion(Expr* From, QualType ToType,
 /// contain the standard conversion sequence required to perform this
 /// conversion and this routine will return true. Otherwise, this
 /// routine will return false and the value of SCS is unspecified.
-bool 
-Sema::IsStandardConversion(Expr* From, QualType ToType, 
+bool
+Sema::IsStandardConversion(Expr* From, QualType ToType,
                            bool InOverloadResolution,
-                           StandardConversionSequence &SCS)
-{
+                           StandardConversionSequence &SCS) {
   QualType FromType = From->getType();
 
   // Standard conversions (C++ [conv])
@@ -485,23 +480,23 @@ Sema::IsStandardConversion(Expr* From, QualType ToType,
   SCS.CopyConstructor = 0;
 
   // There are no standard conversions for class types in C++, so
-  // abort early. When overloading in C, however, we do permit 
+  // abort early. When overloading in C, however, we do permit
   if (FromType->isRecordType() || ToType->isRecordType()) {
     if (getLangOptions().CPlusPlus)
       return false;
 
-    // When we're overloading in C, we allow, as standard conversions, 
+    // When we're overloading in C, we allow, as standard conversions,
   }
 
   // The first conversion can be an lvalue-to-rvalue conversion,
   // array-to-pointer conversion, or function-to-pointer conversion
   // (C++ 4p1).
 
-  // Lvalue-to-rvalue conversion (C++ 4.1): 
+  // Lvalue-to-rvalue conversion (C++ 4.1):
   //   An lvalue (3.10) of a non-function, non-array type T can be
   //   converted to an rvalue.
   Expr::isLvalueResult argIsLvalue = From->isLvalue(Context);
-  if (argIsLvalue == Expr::LV_Valid && 
+  if (argIsLvalue == Expr::LV_Valid &&
       !FromType->isFunctionType() && !FromType->isArrayType() &&
       Context.getCanonicalType(FromType) != Context.OverloadTy) {
     SCS.First = ICK_Lvalue_To_Rvalue;
@@ -543,7 +538,7 @@ Sema::IsStandardConversion(Expr* From, QualType ToType,
     // type "pointer to T." The result is a pointer to the
     // function. (C++ 4.3p1).
     FromType = Context.getPointerType(FromType);
-  } else if (FunctionDecl *Fn 
+  } else if (FunctionDecl *Fn
              = ResolveAddressOfOverloadedFunction(From, ToType, false)) {
     // Address of overloaded function (C++ [over.over]).
     SCS.First = ICK_Function_To_Pointer;
@@ -584,7 +579,7 @@ Sema::IsStandardConversion(Expr* From, QualType ToType,
     // conversion to do.
     SCS.Second = ICK_Identity;
   } else if (IsIntegralPromotion(From, FromType, ToType)) {
-    // Integral promotion (C++ 4.5).  
+    // Integral promotion (C++ 4.5).
     SCS.Second = ICK_Integral_Promotion;
     FromType = ToType.getUnqualifiedType();
   } else if (IsFloatingPointPromotion(FromType, ToType)) {
@@ -612,7 +607,7 @@ Sema::IsStandardConversion(Expr* From, QualType ToType,
   } else if ((FromType->isFloatingType() &&
               ToType->isIntegralType() && (!ToType->isBooleanType() &&
                                            !ToType->isEnumeralType())) ||
-             ((FromType->isIntegralType() || FromType->isEnumeralType()) && 
+             ((FromType->isIntegralType() || FromType->isEnumeralType()) &&
               ToType->isFloatingType())) {
     // Floating-integral conversions (C++ 4.9).
     // FIXME: isIntegralType shouldn't be true for enums in C++.
@@ -641,7 +636,7 @@ Sema::IsStandardConversion(Expr* From, QualType ToType,
     // Boolean conversions (C++ 4.12).
     SCS.Second = ICK_Boolean_Conversion;
     FromType = Context.BoolTy;
-  } else if (!getLangOptions().CPlusPlus && 
+  } else if (!getLangOptions().CPlusPlus &&
              Context.typesAreCompatible(ToType, FromType)) {
     // Compatible conversions (Clang extension for C function overloading)
     SCS.Second = ICK_Compatible_Conversion;
@@ -662,12 +657,12 @@ Sema::IsStandardConversion(Expr* From, QualType ToType,
     // No conversion required
     SCS.Third = ICK_Identity;
 
-    // C++ [over.best.ics]p6: 
+    // C++ [over.best.ics]p6:
     //   [...] Any difference in top-level cv-qualification is
     //   subsumed by the initialization itself and does not constitute
     //   a conversion. [...]
     CanonFrom = Context.getCanonicalType(FromType);
-    CanonTo = Context.getCanonicalType(ToType);    
+    CanonTo = Context.getCanonicalType(ToType);
     if (CanonFrom.getUnqualifiedType() == CanonTo.getUnqualifiedType() &&
         CanonFrom.getCVRQualifiers() != CanonTo.getCVRQualifiers()) {
       FromType = ToType;
@@ -688,8 +683,7 @@ Sema::IsStandardConversion(Expr* From, QualType ToType,
 /// expression From (whose potentially-adjusted type is FromType) to
 /// ToType is an integral promotion (C++ 4.5). If so, returns true and
 /// sets PromotedType to the promoted type.
-bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType)
-{
+bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
   const BuiltinType *To = ToType->getAsBuiltinType();
   // All integers are built-in.
   if (!To) {
@@ -706,7 +700,7 @@ bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType)
         (FromType->isSignedIntegerType() ||
          // We can promote any unsigned integer type whose size is
          // less than int to an int.
-         (!FromType->isSignedIntegerType() && 
+         (!FromType->isSignedIntegerType() &&
           Context.getTypeSize(FromType) < Context.getTypeSize(ToType)))) {
       return To->getKind() == BuiltinType::Int;
     }
@@ -734,15 +728,15 @@ bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType)
 
     // The types we'll try to promote to, in the appropriate
     // order. Try each of these types.
-    QualType PromoteTypes[6] = { 
-      Context.IntTy, Context.UnsignedIntTy, 
+    QualType PromoteTypes[6] = {
+      Context.IntTy, Context.UnsignedIntTy,
       Context.LongTy, Context.UnsignedLongTy ,
       Context.LongLongTy, Context.UnsignedLongLongTy
     };
     for (int Idx = 0; Idx < 6; ++Idx) {
       uint64_t ToSize = Context.getTypeSize(PromoteTypes[Idx]);
       if (FromSize < ToSize ||
-          (FromSize == ToSize && 
+          (FromSize == ToSize &&
            FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) {
         // We found the type that we can promote to. If this is the
         // type we wanted, we have a promotion. Otherwise, no
@@ -770,23 +764,23 @@ bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType)
           MemberDecl->getBitWidth()->isIntegerConstantExpr(BitWidth, Context)) {
         APSInt ToSize(BitWidth.getBitWidth(), BitWidth.isUnsigned());
         ToSize = Context.getTypeSize(ToType);
-        
+
         // Are we promoting to an int from a bitfield that fits in an int?
         if (BitWidth < ToSize ||
             (FromType->isSignedIntegerType() && BitWidth <= ToSize)) {
           return To->getKind() == BuiltinType::Int;
         }
-        
+
         // Are we promoting to an unsigned int from an unsigned bitfield
         // that fits into an unsigned int?
         if (FromType->isUnsignedIntegerType() && BitWidth <= ToSize) {
           return To->getKind() == BuiltinType::UInt;
         }
-        
+
         return false;
       }
     }
-  
+
   // An rvalue of type bool can be converted to an rvalue of type int,
   // with false becoming zero and true becoming one (C++ 4.5p4).
   if (FromType->isBooleanType() && To->getKind() == BuiltinType::Int) {
@@ -799,8 +793,7 @@ bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType)
 /// IsFloatingPointPromotion - Determines whether the conversion from
 /// FromType to ToType is a floating point promotion (C++ 4.6). If so,
 /// returns true and sets PromotedType to the promoted type.
-bool Sema::IsFloatingPointPromotion(QualType FromType, QualType ToType)
-{
+bool Sema::IsFloatingPointPromotion(QualType FromType, QualType ToType) {
   /// An rvalue of type float can be converted to an rvalue of type
   /// double. (C++ 4.6p1).
   if (const BuiltinType *FromBuiltin = FromType->getAsBuiltinType())
@@ -847,15 +840,15 @@ bool Sema::IsComplexPromotion(QualType FromType, QualType ToType) {
 /// same type qualifiers as FromPtr has on its pointee type. ToType,
 /// if non-empty, will be a pointer to ToType that may or may not have
 /// the right set of qualifiers on its pointee.
-static QualType 
-BuildSimilarlyQualifiedPointerType(const PointerType *FromPtr, 
+static QualType
+BuildSimilarlyQualifiedPointerType(const PointerType *FromPtr,
                                    QualType ToPointee, QualType ToType,
                                    ASTContext &Context) {
   QualType CanonFromPointee = Context.getCanonicalType(FromPtr->getPointeeType());
   QualType CanonToPointee = Context.getCanonicalType(ToPointee);
   unsigned Quals = CanonFromPointee.getCVRQualifiers();
-  
-  // Exact qualifier match -> return the pointer type we're converting to.  
+
+  // Exact qualifier match -> return the pointer type we're converting to.
   if (CanonToPointee.getCVRQualifiers() == Quals) {
     // ToType is exactly what we need. Return it.
     if (ToType.getTypePtr())
@@ -870,7 +863,7 @@ BuildSimilarlyQualifiedPointerType(const PointerType *FromPtr,
   return Context.getPointerType(CanonToPointee.getQualifiedType(Quals));
 }
 
-static bool isNullPointerConstantForConversion(Expr *Expr, 
+static bool isNullPointerConstantForConversion(Expr *Expr,
                                                bool InOverloadResolution,
                                                ASTContext &Context) {
   // Handle value-dependent integral null pointer constants correctly.
@@ -881,7 +874,7 @@ static bool isNullPointerConstantForConversion(Expr *Expr,
 
   return Expr->isNullPointerConstant(Context);
 }
-  
+
 /// IsPointerConversion - Determines whether the conversion of the
 /// expression From, which has the (possibly adjusted) type FromType,
 /// can be converted to the type ToType via a pointer conversion (C++
@@ -901,14 +894,13 @@ static bool isNullPointerConstantForConversion(Expr *Expr,
 bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
                                bool InOverloadResolution,
                                QualType& ConvertedType,
-                               bool &IncompatibleObjC)
-{
+                               bool &IncompatibleObjC) {
   IncompatibleObjC = false;
   if (isObjCPointerConversion(FromType, ToType, ConvertedType, IncompatibleObjC))
     return true;
 
-  // Conversion from a null pointer constant to any Objective-C pointer type. 
-  if (ToType->isObjCObjectPointerType() && 
+  // Conversion from a null pointer constant to any Objective-C pointer type.
+  if (ToType->isObjCObjectPointerType() &&
       isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
     ConvertedType = ToType;
     return true;
@@ -922,7 +914,7 @@ bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
   }
   // Blocks: A null pointer constant can be converted to a block
   // pointer type.
-  if (ToType->isBlockPointerType() && 
+  if (ToType->isBlockPointerType() &&
       isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
     ConvertedType = ToType;
     return true;
@@ -930,7 +922,7 @@ bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
 
   // If the left-hand-side is nullptr_t, the right side can be a null
   // pointer constant.
-  if (ToType->isNullPtrType() && 
+  if (ToType->isNullPtrType() &&
       isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
     ConvertedType = ToType;
     return true;
@@ -958,7 +950,7 @@ bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
   // can be converted to an rvalue of type "pointer to cv void" (C++
   // 4.10p2).
   if (FromPointeeType->isObjectType() && ToPointeeType->isVoidType()) {
-    ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr, 
+    ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
                                                        ToPointeeType,
                                                        ToType, Context);
     return true;
@@ -966,16 +958,16 @@ bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
 
   // When we're overloading in C, we allow a special kind of pointer
   // conversion for compatible-but-not-identical pointee types.
-  if (!getLangOptions().CPlusPlus && 
+  if (!getLangOptions().CPlusPlus &&
       Context.typesAreCompatible(FromPointeeType, ToPointeeType)) {
-    ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr, 
+    ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
                                                        ToPointeeType,
-                                                       ToType, Context);    
+                                                       ToType, Context);
     return true;
   }
 
   // C++ [conv.ptr]p3:
-  // 
+  //
   //   An rvalue of type "pointer to cv D," where D is a class type,
   //   can be converted to an rvalue of type "pointer to cv B," where
   //   B is a base class (clause 10) of D. If B is an inaccessible
@@ -990,7 +982,7 @@ bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
   if (getLangOptions().CPlusPlus &&
       FromPointeeType->isRecordType() && ToPointeeType->isRecordType() &&
       IsDerivedFrom(FromPointeeType, ToPointeeType)) {
-    ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr, 
+    ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
                                                        ToPointeeType,
                                                        ToType, Context);
     return true;
@@ -1002,7 +994,7 @@ bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
 /// isObjCPointerConversion - Determines whether this is an
 /// Objective-C pointer conversion. Subroutine of IsPointerConversion,
 /// with the same arguments and return values.
-bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType, 
+bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType,
                                    QualType& ConvertedType,
                                    bool &IncompatibleObjC) {
   if (!getLangOptions().ObjC1)
@@ -1010,7 +1002,7 @@ bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType,
 
   // First, we handle all conversions on ObjC object pointer types.
   const ObjCObjectPointerType* ToObjCPtr = ToType->getAsObjCObjectPointerType();
-  const ObjCObjectPointerType *FromObjCPtr = 
+  const ObjCObjectPointerType *FromObjCPtr =
     FromType->getAsObjCObjectPointerType();
 
   if (ToObjCPtr && FromObjCPtr) {
@@ -1021,9 +1013,9 @@ bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType,
       return true;
     }
     // Conversions with Objective-C's id<...>.
-    if ((FromObjCPtr->isObjCQualifiedIdType() || 
+    if ((FromObjCPtr->isObjCQualifiedIdType() ||
          ToObjCPtr->isObjCQualifiedIdType()) &&
-        Context.ObjCQualifiedIdTypesAreCompatible(ToType, FromType, 
+        Context.ObjCQualifiedIdTypesAreCompatible(ToType, FromType,
                                                   /*compare=*/false)) {
       ConvertedType = ToType;
       return true;
@@ -1043,7 +1035,7 @@ bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType,
       ConvertedType = FromType;
       return true;
     }
-  } 
+  }
   // Beyond this point, both types need to be C pointers or block pointers.
   QualType ToPointeeType;
   if (const PointerType *ToCPtr = ToType->getAs<PointerType>())
@@ -1075,7 +1067,7 @@ bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType,
   // differences in the argument and result types are in Objective-C
   // pointer conversions. If so, we permit the conversion (but
   // complain about it).
-  const FunctionProtoType *FromFunctionType 
+  const FunctionProtoType *FromFunctionType
     = FromPointeeType->getAsFunctionProtoType();
   const FunctionProtoType *ToFunctionType
     = ToPointeeType->getAsFunctionProtoType();
@@ -1106,7 +1098,7 @@ bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType,
       // Function types are too different. Abort.
       return false;
     }
-     
+
     // Check argument types.
     for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumArgs();
          ArgIdx != NumArgs; ++ArgIdx) {
@@ -1160,9 +1152,9 @@ bool Sema::CheckPointerConversion(Expr *From, QualType ToType) {
                                             From->getSourceRange());
       }
     }
-  if (const ObjCObjectPointerType *FromPtrType = 
+  if (const ObjCObjectPointerType *FromPtrType =
         FromType->getAsObjCObjectPointerType())
-    if (const ObjCObjectPointerType *ToPtrType = 
+    if (const ObjCObjectPointerType *ToPtrType =
           ToType->getAsObjCObjectPointerType()) {
       // Objective-C++ conversions are always okay.
       // FIXME: We should have a different class of conversions for the
@@ -1180,8 +1172,7 @@ bool Sema::CheckPointerConversion(Expr *From, QualType ToType) {
 /// If so, returns true and places the converted type (that might differ from
 /// ToType in its cv-qualifiers at some level) into ConvertedType.
 bool Sema::IsMemberPointerConversion(Expr *From, QualType FromType,
-                                     QualType ToType, QualType &ConvertedType)
-{
+                                     QualType ToType, QualType &ConvertedType) {
   const MemberPointerType *ToTypePtr = ToType->getAs<MemberPointerType>();
   if (!ToTypePtr)
     return false;
@@ -1218,13 +1209,13 @@ bool Sema::IsMemberPointerConversion(Expr *From, QualType FromType,
 /// for which IsMemberPointerConversion has already returned true. It returns
 /// true and produces a diagnostic if there was an error, or returns false
 /// otherwise.
-bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType, 
+bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType,
                                         CastExpr::CastKind &Kind) {
   QualType FromType = From->getType();
   const MemberPointerType *FromPtrType = FromType->getAs<MemberPointerType>();
   if (!FromPtrType) {
     // This must be a null pointer to member pointer conversion
-    assert(From->isNullPointerConstant(Context) && 
+    assert(From->isNullPointerConstant(Context) &&
            "Expr must be null pointer constant!");
     Kind = CastExpr::CK_NullToMemberPointer;
     return false;
@@ -1278,9 +1269,8 @@ bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType,
 /// IsQualificationConversion - Determines whether the conversion from
 /// an rvalue of type FromType to ToType is a qualification conversion
 /// (C++ 4.4).
-bool 
-Sema::IsQualificationConversion(QualType FromType, QualType ToType)
-{
+bool
+Sema::IsQualificationConversion(QualType FromType, QualType ToType) {
   FromType = Context.getCanonicalType(FromType);
   ToType = Context.getCanonicalType(ToType);
 
@@ -1307,16 +1297,16 @@ Sema::IsQualificationConversion(QualType FromType, QualType ToType)
     //      2,j, and similarly for volatile.
     if (!ToType.isAtLeastAsQualifiedAs(FromType))
       return false;
-    
+
     //   -- if the cv 1,j and cv 2,j are different, then const is in
     //      every cv for 0 < k < j.
     if (FromType.getCVRQualifiers() != ToType.getCVRQualifiers()
         && !PreviousToQualsIncludeConst)
       return false;
-    
+
     // Keep track of whether all prior cv-qualifiers in the "to" type
     // include const.
-    PreviousToQualsIncludeConst 
+    PreviousToQualsIncludeConst
       = PreviousToQualsIncludeConst && ToType.isConstQualified();
   }
 
@@ -1359,14 +1349,13 @@ static void GetFunctionAndTemplate(AnyFunctionDecl Orig, T *&Function,
 ///
 /// \param ForceRValue  true if the expression should be treated as an rvalue
 /// for overload resolution.
-bool Sema::IsUserDefinedConversion(Expr *From, QualType ToType, 
+bool Sema::IsUserDefinedConversion(Expr *From, QualType ToType,
                                    UserDefinedConversionSequence& User,
                                    bool AllowConversionFunctions,
-                                   bool AllowExplicit, bool ForceRValue)
-{
+                                   bool AllowExplicit, bool ForceRValue) {
   OverloadCandidateSet CandidateSet;
   if (const RecordType *ToRecordType = ToType->getAs<RecordType>()) {
-    if (CXXRecordDecl *ToRecordDecl 
+    if (CXXRecordDecl *ToRecordDecl
           = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) {
       // C++ [over.match.ctor]p1:
       //   When objects of class type are direct-initialized (8.5), or
@@ -1376,11 +1365,11 @@ bool Sema::IsUserDefinedConversion(Expr *From, QualType ToType,
       //   functions are all the converting constructors (12.3.1) of
       //   that class. The argument list is the expression-list within
       //   the parentheses of the initializer.
-      DeclarationName ConstructorName 
+      DeclarationName ConstructorName
         = Context.DeclarationNames.getCXXConstructorName(
                           Context.getCanonicalType(ToType).getUnqualifiedType());
       DeclContext::lookup_iterator Con, ConEnd;
-      for (llvm::tie(Con, ConEnd) 
+      for (llvm::tie(Con, ConEnd)
              = ToRecordDecl->lookup(ConstructorName);
            Con != ConEnd; ++Con) {
         // Find the constructor (which may be a template).
@@ -1388,17 +1377,17 @@ bool Sema::IsUserDefinedConversion(Expr *From, QualType ToType,
         FunctionTemplateDecl *ConstructorTmpl
           = dyn_cast<FunctionTemplateDecl>(*Con);
         if (ConstructorTmpl)
-          Constructor 
+          Constructor
             = cast<CXXConstructorDecl>(ConstructorTmpl->getTemplatedDecl());
         else
           Constructor = cast<CXXConstructorDecl>(*Con);
-        
+
         if (!Constructor->isInvalidDecl() &&
             Constructor->isConvertingConstructor(AllowExplicit)) {
           if (ConstructorTmpl)
-            AddTemplateOverloadCandidate(ConstructorTmpl, false, 0, 0, &From, 
+            AddTemplateOverloadCandidate(ConstructorTmpl, false, 0, 0, &From,
                                          1, CandidateSet,
-                                         /*SuppressUserConversions=*/true, 
+                                         /*SuppressUserConversions=*/true,
                                          ForceRValue);
           else
             AddOverloadCandidate(Constructor, &From, 1, CandidateSet,
@@ -1410,19 +1399,19 @@ bool Sema::IsUserDefinedConversion(Expr *From, QualType ToType,
 
   if (!AllowConversionFunctions) {
     // Don't allow any conversion functions to enter the overload set.
-  } else if (RequireCompleteType(From->getLocStart(), From->getType(), 
-                                 PDiag(0) 
+  } else if (RequireCompleteType(From->getLocStart(), From->getType(),
+                                 PDiag(0)
                                    << From->getSourceRange())) {
     // No conversion functions from incomplete types.
-  } else if (const RecordType *FromRecordType 
+  } else if (const RecordType *FromRecordType
                = From->getType()->getAs<RecordType>()) {
-    if (CXXRecordDecl *FromRecordDecl 
+    if (CXXRecordDecl *FromRecordDecl
           = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) {
       // Add all of the conversion functions as candidates.
       // FIXME: Look for conversions in base classes!
-      OverloadedFunctionDecl *Conversions 
+      OverloadedFunctionDecl *Conversions
         = FromRecordDecl->getConversionFunctions();
-      for (OverloadedFunctionDecl::function_iterator Func 
+      for (OverloadedFunctionDecl::function_iterator Func
              = Conversions->function_begin();
            Func != Conversions->function_end(); ++Func) {
         CXXConversionDecl *Conv;
@@ -1430,12 +1419,12 @@ bool Sema::IsUserDefinedConversion(Expr *From, QualType ToType,
         GetFunctionAndTemplate(*Func, Conv, ConvTemplate);
         if (ConvTemplate)
           Conv = dyn_cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
-        else 
+        else
           Conv = dyn_cast<CXXConversionDecl>(*Func);
 
         if (AllowExplicit || !Conv->isExplicit()) {
           if (ConvTemplate)
-            AddTemplateConversionCandidate(ConvTemplate, From, ToType, 
+            AddTemplateConversionCandidate(ConvTemplate, From, ToType,
                                            CandidateSet);
           else
             AddConversionCandidate(Conv, From, ToType, CandidateSet);
@@ -1448,7 +1437,7 @@ bool Sema::IsUserDefinedConversion(Expr *From, QualType ToType,
   switch (BestViableFunction(CandidateSet, From->getLocStart(), Best)) {
     case OR_Success:
       // Record the standard conversion we used and the conversion function.
-      if (CXXConstructorDecl *Constructor 
+      if (CXXConstructorDecl *Constructor
             = dyn_cast<CXXConstructorDecl>(Best->Function)) {
         // C++ [over.ics.user]p1:
         //   If the user-defined conversion is specified by a
@@ -1461,7 +1450,7 @@ bool Sema::IsUserDefinedConversion(Expr *From, QualType ToType,
         User.Before = Best->Conversions[0].Standard;
         User.ConversionFunction = Constructor;
         User.After.setAsIdentityConversion();
-        User.After.FromTypePtr 
+        User.After.FromTypePtr
           = ThisType->getAs<PointerType>()->getPointeeType().getAsOpaquePtr();
         User.After.ToTypePtr = ToType.getAsOpaquePtr();
         return true;
@@ -1475,8 +1464,8 @@ bool Sema::IsUserDefinedConversion(Expr *From, QualType ToType,
         //   implicit object parameter of the conversion function.
         User.Before = Best->Conversions[0].Standard;
         User.ConversionFunction = Conversion;
-        
-        // C++ [over.ics.user]p2: 
+
+        // C++ [over.ics.user]p2:
         //   The second standard conversion sequence converts the
         //   result of the user-defined conversion to the target type
         //   for the sequence. Since an implicit conversion sequence
@@ -1491,7 +1480,7 @@ bool Sema::IsUserDefinedConversion(Expr *From, QualType ToType,
         assert(false && "Not a constructor or conversion function?");
         return false;
       }
-      
+
     case OR_No_Viable_Function:
     case OR_Deleted:
       // No conversion here! We're done.
@@ -1509,7 +1498,7 @@ bool Sema::IsUserDefinedConversion(Expr *From, QualType ToType,
 /// CompareImplicitConversionSequences - Compare two implicit
 /// conversion sequences to determine whether one is better than the
 /// other or if they are indistinguishable (C++ 13.3.3.2).
-ImplicitConversionSequence::CompareKind 
+ImplicitConversionSequence::CompareKind
 Sema::CompareImplicitConversionSequences(const ImplicitConversionSequence& ICS1,
                                          const ImplicitConversionSequence& ICS2)
 {
@@ -1521,7 +1510,7 @@ Sema::CompareImplicitConversionSequences(const ImplicitConversionSequence& ICS1,
   //   -- a user-defined conversion sequence (13.3.3.1.2) is a better
   //      conversion sequence than an ellipsis conversion sequence
   //      (13.3.3.1.3).
-  // 
+  //
   if (ICS1.ConversionKind < ICS2.ConversionKind)
     return ImplicitConversionSequence::Better;
   else if (ICS2.ConversionKind < ICS1.ConversionKind)
@@ -1532,7 +1521,7 @@ Sema::CompareImplicitConversionSequences(const ImplicitConversionSequence& ICS1,
   // following rules apply: (C++ 13.3.3.2p3):
   if (ICS1.ConversionKind == ImplicitConversionSequence::StandardConversion)
     return CompareStandardConversionSequences(ICS1.Standard, ICS2.Standard);
-  else if (ICS1.ConversionKind == 
+  else if (ICS1.ConversionKind ==
              ImplicitConversionSequence::UserDefinedConversion) {
     // User-defined conversion sequence U1 is a better conversion
     // sequence than another user-defined conversion sequence U2 if
@@ -1540,7 +1529,7 @@ Sema::CompareImplicitConversionSequences(const ImplicitConversionSequence& ICS1,
     // constructor and if the second standard conversion sequence of
     // U1 is better than the second standard conversion sequence of
     // U2 (C++ 13.3.3.2p3).
-    if (ICS1.UserDefined.ConversionFunction == 
+    if (ICS1.UserDefined.ConversionFunction ==
           ICS2.UserDefined.ConversionFunction)
       return CompareStandardConversionSequences(ICS1.UserDefined.After,
                                                 ICS2.UserDefined.After);
@@ -1552,7 +1541,7 @@ Sema::CompareImplicitConversionSequences(const ImplicitConversionSequence& ICS1,
 /// CompareStandardConversionSequences - Compare two standard
 /// conversion sequences to determine whether one is better than the
 /// other or if they are indistinguishable (C++ 13.3.3.2p3).
-ImplicitConversionSequence::CompareKind 
+ImplicitConversionSequence::CompareKind
 Sema::CompareStandardConversionSequences(const StandardConversionSequence& SCS1,
                                          const StandardConversionSequence& SCS2)
 {
@@ -1569,13 +1558,13 @@ Sema::CompareStandardConversionSequences(const StandardConversionSequence& SCS1,
     ;
   else if ((SCS1.Second == ICK_Identity && SCS1.Third == SCS2.Third) ||
            (SCS1.Third == ICK_Identity && SCS1.Second == SCS2.Second) ||
-           (SCS1.Second == ICK_Identity && 
+           (SCS1.Second == ICK_Identity &&
             SCS1.Third == ICK_Identity))
     // SCS1 is a proper subsequence of SCS2.
     return ImplicitConversionSequence::Better;
   else if ((SCS2.Second == ICK_Identity && SCS2.Third == SCS1.Third) ||
            (SCS2.Third == ICK_Identity && SCS2.Second == SCS1.Second) ||
-           (SCS2.Second == ICK_Identity && 
+           (SCS2.Second == ICK_Identity &&
             SCS2.Third == ICK_Identity))
     // SCS2 is a proper subsequence of SCS1.
     return ImplicitConversionSequence::Worse;
@@ -1592,7 +1581,7 @@ Sema::CompareStandardConversionSequences(const StandardConversionSequence& SCS1,
   // (C++ 13.3.3.2p4): Two conversion sequences with the same rank
   // are indistinguishable unless one of the following rules
   // applies:
-  
+
   //   A conversion that is not a conversion of a pointer, or
   //   pointer to member, to bool is better than another conversion
   //   that is such a conversion.
@@ -1607,9 +1596,9 @@ Sema::CompareStandardConversionSequences(const StandardConversionSequence& SCS1,
   //   conversion of B* to A* is better than conversion of B* to
   //   void*, and conversion of A* to void* is better than conversion
   //   of B* to void*.
-  bool SCS1ConvertsToVoid 
+  bool SCS1ConvertsToVoid
     = SCS1.isPointerConversionToVoidPointer(Context);
-  bool SCS2ConvertsToVoid 
+  bool SCS2ConvertsToVoid
     = SCS2.isPointerConversionToVoidPointer(Context);
   if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) {
     // Exactly one of the conversion sequences is a conversion to
@@ -1636,7 +1625,7 @@ Sema::CompareStandardConversionSequences(const StandardConversionSequence& SCS1,
     if (SCS2.First == ICK_Array_To_Pointer)
       FromType2 = Context.getArrayDecayedType(FromType2);
 
-    QualType FromPointee1 
+    QualType FromPointee1
       = FromType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
     QualType FromPointee2
       = FromType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType();
@@ -1660,7 +1649,7 @@ Sema::CompareStandardConversionSequences(const StandardConversionSequence& SCS1,
 
   // Compare based on qualification conversions (C++ 13.3.3.2p3,
   // bullet 3).
-  if (ImplicitConversionSequence::CompareKind QualCK 
+  if (ImplicitConversionSequence::CompareKind QualCK
         = CompareQualificationConversions(SCS1, SCS2))
     return QualCK;
 
@@ -1700,11 +1689,10 @@ Sema::CompareStandardConversionSequences(const StandardConversionSequence& SCS1,
 
 /// CompareQualificationConversions - Compares two standard conversion
 /// sequences to determine whether they can be ranked based on their
-/// qualification conversions (C++ 13.3.3.2p3 bullet 3). 
-ImplicitConversionSequence::CompareKind 
+/// qualification conversions (C++ 13.3.3.2p3 bullet 3).
+ImplicitConversionSequence::CompareKind
 Sema::CompareQualificationConversions(const StandardConversionSequence& SCS1,
-                                      const StandardConversionSequence& SCS2)
-{
+                                      const StandardCon