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, 272 insertions, 272 deletions

diff --git a/lib/Sema/SemaTemplateDeduction.cpp b/lib/Sema/SemaTemplateDeduction.cpp
index 2253a4e6a7..b861dcabfe 100644
--- a/lib/Sema/SemaTemplateDeduction.cpp
+++ b/lib/Sema/SemaTemplateDeduction.cpp
@@ -45,7 +45,7 @@ namespace clang {
 using namespace clang;
 
 static Sema::TemplateDeductionResult
-DeduceTemplateArguments(ASTContext &Context, 
+DeduceTemplateArguments(ASTContext &Context,
                         TemplateParameterList *TemplateParams,
                         const TemplateArgument &Param,
                         const TemplateArgument &Arg,
@@ -58,27 +58,27 @@ DeduceTemplateArguments(ASTContext &Context,
 static NonTypeTemplateParmDecl *getDeducedParameterFromExpr(Expr *E) {
   if (ImplicitCastExpr *IC = dyn_cast<ImplicitCastExpr>(E))
     E = IC->getSubExpr();
-  
+
   if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
     return dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
-  
+
   return 0;
 }
 
-/// \brief Deduce the value of the given non-type template parameter 
+/// \brief Deduce the value of the given non-type template parameter
 /// from the given constant.
 static Sema::TemplateDeductionResult
-DeduceNonTypeTemplateArgument(ASTContext &Context, 
-                              NonTypeTemplateParmDecl *NTTP, 
+DeduceNonTypeTemplateArgument(ASTContext &Context,
+                              NonTypeTemplateParmDecl *NTTP,
                               llvm::APSInt Value,
                               Sema::TemplateDeductionInfo &Info,
                               llvm::SmallVectorImpl<TemplateArgument> &Deduced) {
-  assert(NTTP->getDepth() == 0 && 
+  assert(NTTP->getDepth() == 0 &&
          "Cannot deduce non-type template argument with depth > 0");
-  
+
   if (Deduced[NTTP->getIndex()].isNull()) {
     QualType T = NTTP->getType();
-    
+
     // FIXME: Make sure we didn't overflow our data type!
     unsigned AllowedBits = Context.getTypeSize(T);
     if (Value.getBitWidth() != AllowedBits)
@@ -88,10 +88,10 @@ DeduceNonTypeTemplateArgument(ASTContext &Context,
     Deduced[NTTP->getIndex()] = TemplateArgument(SourceLocation(), Value, T);
     return Sema::TDK_Success;
   }
-  
+
   assert(Deduced[NTTP->getIndex()].getKind() == TemplateArgument::Integral);
-  
-  // If the template argument was previously deduced to a negative value, 
+
+  // If the template argument was previously deduced to a negative value,
   // then our deduction fails.
   const llvm::APSInt *PrevValuePtr = Deduced[NTTP->getIndex()].getAsIntegral();
   if (PrevValuePtr->isNegative()) {
@@ -117,35 +117,35 @@ DeduceNonTypeTemplateArgument(ASTContext &Context,
   return Sema::TDK_Success;
 }
 
-/// \brief Deduce the value of the given non-type template parameter 
+/// \brief Deduce the value of the given non-type template parameter
 /// from the given type- or value-dependent expression.
 ///
 /// \returns true if deduction succeeded, false otherwise.
 
 static Sema::TemplateDeductionResult
-DeduceNonTypeTemplateArgument(ASTContext &Context, 
+DeduceNonTypeTemplateArgument(ASTContext &Context,
                               NonTypeTemplateParmDecl *NTTP,
                               Expr *Value,
                               Sema::TemplateDeductionInfo &Info,
                            llvm::SmallVectorImpl<TemplateArgument> &Deduced) {
-  assert(NTTP->getDepth() == 0 && 
+  assert(NTTP->getDepth() == 0 &&
          "Cannot deduce non-type template argument with depth > 0");
   assert((Value->isTypeDependent() || Value->isValueDependent()) &&
          "Expression template argument must be type- or value-dependent.");
-  
+
   if (Deduced[NTTP->getIndex()].isNull()) {
     // FIXME: Clone the Value?
     Deduced[NTTP->getIndex()] = TemplateArgument(Value);
     return Sema::TDK_Success;
   }
-  
+
   if (Deduced[NTTP->getIndex()].getKind() == TemplateArgument::Integral) {
-    // Okay, we deduced a constant in one case and a dependent expression 
-    // in another case. FIXME: Later, we will check that instantiating the 
+    // Okay, we deduced a constant in one case and a dependent expression
+    // in another case. FIXME: Later, we will check that instantiating the
     // dependent expression gives us the constant value.
     return Sema::TDK_Success;
   }
-  
+
   // FIXME: Compare the expressions for equality!
   return Sema::TDK_Success;
 }
@@ -164,7 +164,7 @@ DeduceTemplateArguments(ASTContext &Context,
 
   TemplateDecl *ParamDecl = Param.getAsTemplateDecl();
   TemplateDecl *ArgDecl = Arg.getAsTemplateDecl();
-  
+
   if (!ParamDecl || !ArgDecl) {
     // FIXME: fill in Info.Param/Info.FirstArg
     return Sema::TDK_Inconsistent;
@@ -180,7 +180,7 @@ DeduceTemplateArguments(ASTContext &Context,
   return Sema::TDK_Success;
 }
 
-/// \brief Deduce the template arguments by comparing the template parameter 
+/// \brief Deduce the template arguments by comparing the template parameter
 /// type (which is a template-id) with the template argument type.
 ///
 /// \param Context the AST context in which this deduction occurs.
@@ -206,11 +206,11 @@ DeduceTemplateArguments(ASTContext &Context,
                         Sema::TemplateDeductionInfo &Info,
                         llvm::SmallVectorImpl<TemplateArgument> &Deduced) {
   assert(Arg->isCanonical() && "Argument type must be canonical");
-  
+
   // Check whether the template argument is a dependent template-id.
   // FIXME: This is untested code; it can be tested when we implement
   // partial ordering of class template partial specializations.
-  if (const TemplateSpecializationType *SpecArg 
+  if (const TemplateSpecializationType *SpecArg
         = dyn_cast<TemplateSpecializationType>(Arg)) {
     // Perform template argument deduction for the template name.
     if (Sema::TemplateDeductionResult Result
@@ -219,9 +219,9 @@ DeduceTemplateArguments(ASTContext &Context,
                                     SpecArg->getTemplateName(),
                                     Info, Deduced))
       return Result;
-    
+
     unsigned NumArgs = Param->getNumArgs();
-    
+
     // FIXME: When one of the template-names refers to a
     // declaration with default template arguments, do we need to
     // fill in those default template arguments here? Most likely,
@@ -231,7 +231,7 @@ DeduceTemplateArguments(ASTContext &Context,
     // the template-id.
     if (SpecArg->getNumArgs() != NumArgs)
       return Sema::TDK_NonDeducedMismatch;
-    
+
     // Perform template argument deduction on each template
     // argument.
     for (unsigned I = 0; I != NumArgs; ++I)
@@ -241,49 +241,49 @@ DeduceTemplateArguments(ASTContext &Context,
                                       SpecArg->getArg(I),
                                       Info, Deduced))
         return Result;
-    
+
     return Sema::TDK_Success;
   }
-  
+
   // If the argument type is a class template specialization, we
   // perform template argument deduction using its template
   // arguments.
   const RecordType *RecordArg = dyn_cast<RecordType>(Arg);
   if (!RecordArg)
     return Sema::TDK_NonDeducedMismatch;
-  
-  ClassTemplateSpecializationDecl *SpecArg 
+
+  ClassTemplateSpecializationDecl *SpecArg
     = dyn_cast<ClassTemplateSpecializationDecl>(RecordArg->getDecl());
   if (!SpecArg)
     return Sema::TDK_NonDeducedMismatch;
-  
+
   // Perform template argument deduction for the template name.
   if (Sema::TemplateDeductionResult Result
-        = DeduceTemplateArguments(Context, 
+        = DeduceTemplateArguments(Context,
                                   Param->getTemplateName(),
                                TemplateName(SpecArg->getSpecializedTemplate()),
                                   Info, Deduced))
     return Result;
-    
+
   // FIXME: Can the # of arguments in the parameter and the argument
   // differ due to default arguments?
   unsigned NumArgs = Param->getNumArgs();
   const TemplateArgumentList &ArgArgs = SpecArg->getTemplateArgs();
   if (NumArgs != ArgArgs.size())
     return Sema::TDK_NonDeducedMismatch;
-  
+
   for (unsigned I = 0; I != NumArgs; ++I)
-    if (Sema::TemplateDeductionResult Result 
+    if (Sema::TemplateDeductionResult Result
           = DeduceTemplateArguments(Context, TemplateParams,
                                     Param->getArg(I),
                                     ArgArgs.get(I),
                                     Info, Deduced))
       return Result;
-    
+
   return Sema::TDK_Success;
 }
 
-/// \brief Returns a completely-unqualified array type, capturing the 
+/// \brief Returns a completely-unqualified array type, capturing the
 /// qualifiers in CVRQuals.
 ///
 /// \param Context the AST context in which the array type was built.
@@ -302,32 +302,32 @@ static QualType getUnqualifiedArrayType(ASTContext &Context, QualType T,
     CVRQuals = T.getCVRQualifiers();
     return T.getUnqualifiedType();
   }
-  
+
   if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(T)) {
     QualType Elt = getUnqualifiedArrayType(Context, CAT->getElementType(),
                                            CVRQuals);
     if (Elt == CAT->getElementType())
       return T;
 
-    return Context.getConstantArrayType(Elt, CAT->getSize(), 
+    return Context.getConstantArrayType(Elt, CAT->getSize(),
                                         CAT->getSizeModifier(), 0);
   }
-  
+
   if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(T)) {
     QualType Elt = getUnqualifiedArrayType(Context, IAT->getElementType(),
                                            CVRQuals);
     if (Elt == IAT->getElementType())
       return T;
-    
+
     return Context.getIncompleteArrayType(Elt, IAT->getSizeModifier(), 0);
   }
-  
+
   const DependentSizedArrayType *DSAT = cast<DependentSizedArrayType>(T);
   QualType Elt = getUnqualifiedArrayType(Context, DSAT->getElementType(),
                                          CVRQuals);
   if (Elt == DSAT->getElementType())
     return T;
-  
+
   return Context.getDependentSizedArrayType(Elt, DSAT->getSizeExpr()->Retain(),
                                             DSAT->getSizeModifier(), 0,
                                             SourceRange());
@@ -349,13 +349,13 @@ static QualType getUnqualifiedArrayType(ASTContext &Context, QualType T,
 /// \param Deduced the deduced template arguments
 ///
 /// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe
-/// how template argument deduction is performed. 
+/// how template argument deduction is performed.
 ///
 /// \returns the result of template argument deduction so far. Note that a
 /// "success" result means that template argument deduction has not yet failed,
 /// but it may still fail, later, for other reasons.
 static Sema::TemplateDeductionResult
-DeduceTemplateArguments(ASTContext &Context, 
+DeduceTemplateArguments(ASTContext &Context,
                         TemplateParameterList *TemplateParams,
                         QualType ParamIn, QualType ArgIn,
                         Sema::TemplateDeductionInfo &Info,
@@ -368,30 +368,30 @@ DeduceTemplateArguments(ASTContext &Context,
 
   // C++0x [temp.deduct.call]p4 bullet 1:
   //   - If the original P is a reference type, the deduced A (i.e., the type
-  //     referred to by the reference) can be more cv-qualified than the 
+  //     referred to by the reference) can be more cv-qualified than the
   //     transformed A.
   if (TDF & TDF_ParamWithReferenceType) {
-    unsigned ExtraQualsOnParam 
+    unsigned ExtraQualsOnParam
       = Param.getCVRQualifiers() & ~Arg.getCVRQualifiers();
     Param.setCVRQualifiers(Param.getCVRQualifiers() & ~ExtraQualsOnParam);
   }
-  
+
   // If the parameter type is not dependent, there is nothing to deduce.
   if (!Param->isDependentType())
     return Sema::TDK_Success;
 
   // C++ [temp.deduct.type]p9:
-  //   A template type argument T, a template template argument TT or a 
-  //   template non-type argument i can be deduced if P and A have one of 
+  //   A template type argument T, a template template argument TT or a
+  //   template non-type argument i can be deduced if P and A have one of
   //   the following forms:
   //
   //     T
   //     cv-list T
-  if (const TemplateTypeParmType *TemplateTypeParm 
+  if (const TemplateTypeParmType *TemplateTypeParm
         = Param->getAsTemplateTypeParmType()) {
     unsigned Index = TemplateTypeParm->getIndex();
     bool RecanonicalizeArg = false;
-    
+
     // If the argument type is an array type, move the qualifiers up to the
     // top level, so they can be matched with the qualifiers on the parameter.
     // FIXME: address spaces, ObjC GC qualifiers
@@ -403,7 +403,7 @@ DeduceTemplateArguments(ASTContext &Context,
         RecanonicalizeArg = true;
       }
     }
-                                          
+
     // The argument type can not be less qualified than the parameter
     // type.
     if (Param.isMoreQualifiedThan(Arg) && !(TDF & TDF_IgnoreQualifiers)) {
@@ -414,23 +414,23 @@ DeduceTemplateArguments(ASTContext &Context,
     }
 
     assert(TemplateTypeParm->getDepth() == 0 && "Can't deduce with depth > 0");
-	  
+
     unsigned Quals = Arg.getCVRQualifiers() & ~Param.getCVRQualifiers();
     QualType DeducedType = Arg.getQualifiedType(Quals);
     if (RecanonicalizeArg)
       DeducedType = Context.getCanonicalType(DeducedType);
-    
+
     if (Deduced[Index].isNull())
       Deduced[Index] = TemplateArgument(SourceLocation(), DeducedType);
     else {
-      // C++ [temp.deduct.type]p2: 
+      // C++ [temp.deduct.type]p2:
       //   [...] If type deduction cannot be done for any P/A pair, or if for
-      //   any pair the deduction leads to more than one possible set of 
-      //   deduced values, or if different pairs yield different deduced 
-      //   values, or if any template argument remains neither deduced nor 
+      //   any pair the deduction leads to more than one possible set of
+      //   deduced values, or if different pairs yield different deduced
+      //   values, or if any template argument remains neither deduced nor
       //   explicitly specified, template argument deduction fails.
       if (Deduced[Index].getAsType() != DeducedType) {
-        Info.Param 
+        Info.Param
           = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
         Info.FirstArg = Deduced[Index];
         Info.SecondArg = TemplateArgument(SourceLocation(), Arg);
@@ -451,7 +451,7 @@ DeduceTemplateArguments(ASTContext &Context,
         return Sema::TDK_NonDeducedMismatch;
     } else {
       if (Param.getCVRQualifiers() != Arg.getCVRQualifiers())
-        return Sema::TDK_NonDeducedMismatch;  
+        return Sema::TDK_NonDeducedMismatch;
     }
   }
 
@@ -459,26 +459,26 @@ DeduceTemplateArguments(ASTContext &Context,
     // No deduction possible for these types
     case Type::Builtin:
       return Sema::TDK_NonDeducedMismatch;
-      
+
     //     T *
     case Type::Pointer: {
       const PointerType *PointerArg = Arg->getAs<PointerType>();
       if (!PointerArg)
         return Sema::TDK_NonDeducedMismatch;
-      
+
       unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass);
       return DeduceTemplateArguments(Context, TemplateParams,
                                    cast<PointerType>(Param)->getPointeeType(),
                                      PointerArg->getPointeeType(),
                                      Info, Deduced, SubTDF);
     }
-      
+
     //     T &
     case Type::LValueReference: {
       const LValueReferenceType *ReferenceArg = Arg->getAs<LValueReferenceType>();
       if (!ReferenceArg)
         return Sema::TDK_NonDeducedMismatch;
-      
+
       return DeduceTemplateArguments(Context, TemplateParams,
                            cast<LValueReferenceType>(Param)->getPointeeType(),
                                      ReferenceArg->getPointeeType(),
@@ -490,20 +490,20 @@ DeduceTemplateArguments(ASTContext &Context,
       const RValueReferenceType *ReferenceArg = Arg->getAs<RValueReferenceType>();
       if (!ReferenceArg)
         return Sema::TDK_NonDeducedMismatch;
-      
+
       return DeduceTemplateArguments(Context, TemplateParams,
                            cast<RValueReferenceType>(Param)->getPointeeType(),
                                      ReferenceArg->getPointeeType(),
                                      Info, Deduced, 0);
     }
-      
+
     //     T [] (implied, but not stated explicitly)
     case Type::IncompleteArray: {
-      const IncompleteArrayType *IncompleteArrayArg = 
+      const IncompleteArrayType *IncompleteArrayArg =
         Context.getAsIncompleteArrayType(Arg);
       if (!IncompleteArrayArg)
         return Sema::TDK_NonDeducedMismatch;
-      
+
       return DeduceTemplateArguments(Context, TemplateParams,
                      Context.getAsIncompleteArrayType(Param)->getElementType(),
                                      IncompleteArrayArg->getElementType(),
@@ -512,16 +512,16 @@ DeduceTemplateArguments(ASTContext &Context,
 
     //     T [integer-constant]
     case Type::ConstantArray: {
-      const ConstantArrayType *ConstantArrayArg = 
+      const ConstantArrayType *ConstantArrayArg =
         Context.getAsConstantArrayType(Arg);
       if (!ConstantArrayArg)
         return Sema::TDK_NonDeducedMismatch;
-      
-      const ConstantArrayType *ConstantArrayParm = 
+
+      const ConstantArrayType *ConstantArrayParm =
         Context.getAsConstantArrayType(Param);
       if (ConstantArrayArg->getSize() != ConstantArrayParm->getSize())
         return Sema::TDK_NonDeducedMismatch;
-      
+
       return DeduceTemplateArguments(Context, TemplateParams,
                                      ConstantArrayParm->getElementType(),
                                      ConstantArrayArg->getElementType(),
@@ -533,7 +533,7 @@ DeduceTemplateArguments(ASTContext &Context,
       const ArrayType *ArrayArg = dyn_cast<ArrayType>(Arg);
       if (!ArrayArg)
         return Sema::TDK_NonDeducedMismatch;
-      
+
       // Check the element type of the arrays
       const DependentSizedArrayType *DependentArrayParm
         = cast<DependentSizedArrayType>(Param);
@@ -543,18 +543,18 @@ DeduceTemplateArguments(ASTContext &Context,
                                       ArrayArg->getElementType(),
                                       Info, Deduced, 0))
         return Result;
-          
+
       // Determine the array bound is something we can deduce.
-      NonTypeTemplateParmDecl *NTTP 
+      NonTypeTemplateParmDecl *NTTP
         = getDeducedParameterFromExpr(DependentArrayParm->getSizeExpr());
       if (!NTTP)
         return Sema::TDK_Success;
-      
-      // We can perform template argument deduction for the given non-type 
+
+      // We can perform template argument deduction for the given non-type
       // template parameter.
-      assert(NTTP->getDepth() == 0 && 
+      assert(NTTP->getDepth() == 0 &&
              "Cannot deduce non-type template argument at depth > 0");
-      if (const ConstantArrayType *ConstantArrayArg 
+      if (const ConstantArrayType *ConstantArrayArg
             = dyn_cast<ConstantArrayType>(ArrayArg)) {
         llvm::APSInt Size(ConstantArrayArg->getSize());
         return DeduceNonTypeTemplateArgument(Context, NTTP, Size,
@@ -565,30 +565,30 @@ DeduceTemplateArguments(ASTContext &Context,
         return DeduceNonTypeTemplateArgument(Context, NTTP,
                                              DependentArrayArg->getSizeExpr(),
                                              Info, Deduced);
-      
+
       // Incomplete type does not match a dependently-sized array type
       return Sema::TDK_NonDeducedMismatch;
     }
-      
-    //     type(*)(T) 
-    //     T(*)() 
-    //     T(*)(T) 
+
+    //     type(*)(T)
+    //     T(*)()
+    //     T(*)(T)
     case Type::FunctionProto: {
-      const FunctionProtoType *FunctionProtoArg = 
+      const FunctionProtoType *FunctionProtoArg =
         dyn_cast<FunctionProtoType>(Arg);
       if (!FunctionProtoArg)
         return Sema::TDK_NonDeducedMismatch;
-      
-      const FunctionProtoType *FunctionProtoParam = 
+
+      const FunctionProtoType *FunctionProtoParam =
         cast<FunctionProtoType>(Param);
 
-      if (FunctionProtoParam->getTypeQuals() != 
+      if (FunctionProtoParam->getTypeQuals() !=
           FunctionProtoArg->getTypeQuals())
         return Sema::TDK_NonDeducedMismatch;
-      
+
       if (FunctionProtoParam->getNumArgs() != FunctionProtoArg->getNumArgs())
         return Sema::TDK_NonDeducedMismatch;
-      
+
       if (FunctionProtoParam->isVariadic() != FunctionProtoArg->isVariadic())
         return Sema::TDK_NonDeducedMismatch;
 
@@ -599,7 +599,7 @@ DeduceTemplateArguments(ASTContext &Context,
                                       FunctionProtoArg->getResultType(),
                                       Info, Deduced, 0))
         return Result;
-      
+
       for (unsigned I = 0, N = FunctionProtoParam->getNumArgs(); I != N; ++I) {
         // Check argument types.
         if (Sema::TemplateDeductionResult Result
@@ -609,10 +609,10 @@ DeduceTemplateArguments(ASTContext &Context,
                                         Info, Deduced, 0))
           return Result;
       }
-      
+
       return Sema::TDK_Success;
     }
-     
+
     //     template-name<T> (where template-name refers to a class template)
     //     template-name<i>
     //     TT<T> (TODO)
@@ -621,26 +621,26 @@ DeduceTemplateArguments(ASTContext &Context,
     case Type::TemplateSpecialization: {
       const TemplateSpecializationType *SpecParam
         = cast<TemplateSpecializationType>(Param);
-      
+
       // Try to deduce template arguments from the template-id.
       Sema::TemplateDeductionResult Result
-        = DeduceTemplateArguments(Context, TemplateParams, SpecParam, Arg,  
+        = DeduceTemplateArguments(Context, TemplateParams, SpecParam, Arg,
                                   Info, Deduced);
-      
-      if (Result && (TDF & TDF_DerivedClass) && 
+
+      if (Result && (TDF & TDF_DerivedClass) &&
           Result != Sema::TDK_Inconsistent) {
         // C++ [temp.deduct.call]p3b3:
         //   If P is a class, and P has the form template-id, then A can be a
         //   derived class of the deduced A. Likewise, if P is a pointer to a
-        //   class of the form template-id, A can be a pointer to a derived 
+        //   class of the form template-id, A can be a pointer to a derived
         //   class pointed to by the deduced A.
         //
         // More importantly:
-        //   These alternatives are considered only if type deduction would 
+        //   These alternatives are considered only if type deduction would
         //   otherwise fail.
         if (const RecordType *RecordT = dyn_cast<RecordType>(Arg)) {
           // Use data recursion to crawl through the list of base classes.
-          // Visited contains the set of nodes we have already visited, while 
+          // Visited contains the set of nodes we have already visited, while
           // ToVisit is our stack of records that we still need to visit.
           llvm::SmallPtrSet<const RecordType *, 8> Visited;
           llvm::SmallVector<const RecordType *, 8> ToVisit;
@@ -650,18 +650,18 @@ DeduceTemplateArguments(ASTContext &Context,
             // Retrieve the next class in the inheritance hierarchy.
             const RecordType *NextT = ToVisit.back();
             ToVisit.pop_back();
-            
+
             // If we have already seen this type, skip it.
             if (!Visited.insert(NextT))
               continue;
-           
+
             // If this is a base class, try to perform template argument
             // deduction from it.
             if (NextT != RecordT) {
               Sema::TemplateDeductionResult BaseResult
                 = DeduceTemplateArguments(Context, TemplateParams, SpecParam,
                                           QualType(NextT, 0), Info, Deduced);
-              
+
               // If template argument deduction for this base was successful,
               // note that we had some success.
               if (BaseResult == Sema::TDK_Success)
@@ -672,24 +672,24 @@ DeduceTemplateArguments(ASTContext &Context,
               else if (BaseResult == Sema::TDK_Inconsistent)
                 return BaseResult;
             }
-            
+
             // Visit base classes
             CXXRecordDecl *Next = cast<CXXRecordDecl>(NextT->getDecl());
             for (CXXRecordDecl::base_class_iterator Base = Next->bases_begin(),
                                                  BaseEnd = Next->bases_end();
                Base != BaseEnd; ++Base) {
-              assert(Base->getType()->isRecordType() && 
+              assert(Base->getType()->isRecordType() &&
                      "Base class that isn't a record?");
               ToVisit.push_back(Base->getType()->getAs<RecordType>());
             }
           }
-          
+
           if (Successful)
             return Sema::TDK_Success;
         }
-        
+
       }
-      
+
       return Result;
     }
 
@@ -724,16 +724,16 @@ DeduceTemplateArguments(ASTContext &Context,
 
     //     (clang extension)
     //
-    //     type(^)(T) 
-    //     T(^)() 
-    //     T(^)(T) 
+    //     type(^)(T)
+    //     T(^)()
+    //     T(^)(T)
     case Type::BlockPointer: {
       const BlockPointerType *BlockPtrParam = cast<BlockPointerType>(Param);
       const BlockPointerType *BlockPtrArg = dyn_cast<BlockPointerType>(Arg);
-      
+
       if (!BlockPtrArg)
         return Sema::TDK_NonDeducedMismatch;
-      
+
       return DeduceTemplateArguments(Context, TemplateParams,
                                      BlockPtrParam->getPointeeType(),
                                      BlockPtrArg->getPointeeType(), Info,
@@ -755,7 +755,7 @@ DeduceTemplateArguments(ASTContext &Context,
 }
 
 static Sema::TemplateDeductionResult
-DeduceTemplateArguments(ASTContext &Context, 
+DeduceTemplateArguments(ASTContext &Context,
                         TemplateParameterList *TemplateParams,
                         const TemplateArgument &Param,
                         const TemplateArgument &Arg,
@@ -765,8 +765,8 @@ DeduceTemplateArguments(ASTContext &Context,
   case TemplateArgument::Null:
     assert(false && "Null template argument in parameter list");
     break;
-      
-  case TemplateArgument::Type: 
+
+  case TemplateArgument::Type:
     assert(Arg.getKind() == TemplateArgument::Type && "Type/value mismatch");
     return DeduceTemplateArguments(Context, TemplateParams, Param.getAsType(),
                                    Arg.getAsType(), Info, Deduced, 0);
@@ -777,7 +777,7 @@ DeduceTemplateArguments(ASTContext &Context,
     Info.FirstArg = Param;
     Info.SecondArg = Arg;
     return Sema::TDK_NonDeducedMismatch;
-      
+
   case TemplateArgument::Integral:
     if (Arg.getKind() == TemplateArgument::Integral) {
       // FIXME: Zero extension + sign checking here?
@@ -799,25 +799,25 @@ DeduceTemplateArguments(ASTContext &Context,
     Info.FirstArg = Param;
     Info.SecondArg = Arg;
     return Sema::TDK_NonDeducedMismatch;
-      
+
   case TemplateArgument::Expression: {
-    if (NonTypeTemplateParmDecl *NTTP 
+    if (NonTypeTemplateParmDecl *NTTP
           = getDeducedParameterFromExpr(Param.getAsExpr())) {
       if (Arg.getKind() == TemplateArgument::Integral)
         // FIXME: Sign problems here
-        return DeduceNonTypeTemplateArgument(Context, NTTP, 
-                                             *Arg.getAsIntegral(), 
+        return DeduceNonTypeTemplateArgument(Context, NTTP,
+                                             *Arg.getAsIntegral(),
                                              Info, Deduced);
       if (Arg.getKind() == TemplateArgument::Expression)
         return DeduceNonTypeTemplateArgument(Context, NTTP, Arg.getAsExpr(),
                                              Info, Deduced);
-      
+
       assert(false && "Type/value mismatch");
       Info.FirstArg = Param;
       Info.SecondArg = Arg;
       return Sema::TDK_NonDeducedMismatch;
     }
-    
+
     // Can't deduce anything, but that's okay.
     return Sema::TDK_Success;
   }
@@ -825,11 +825,11 @@ DeduceTemplateArguments(ASTContext &Context,
     assert(0 && "FIXME: Implement!");
     break;
   }
-      
+
   return Sema::TDK_Success;
 }
 
-static Sema::TemplateDeductionResult 
+static Sema::TemplateDeductionResult
 DeduceTemplateArguments(ASTContext &Context,
                         TemplateParameterList *TemplateParams,
                         const TemplateArgumentList &ParamList,
@@ -840,7 +840,7 @@ DeduceTemplateArguments(ASTContext &Context,
   for (unsigned I = 0, N = ParamList.size(); I != N; ++I) {
     if (Sema::TemplateDeductionResult Result
           = DeduceTemplateArguments(Context, TemplateParams,
-                                    ParamList[I], ArgList[I], 
+                                    ParamList[I], ArgList[I],
                                     Info, Deduced))
       return Result;
   }
@@ -848,41 +848,41 @@ DeduceTemplateArguments(ASTContext &Context,
 }
 
 /// \brief Determine whether two template arguments are the same.
-static bool isSameTemplateArg(ASTContext &Context, 
+static bool isSameTemplateArg(ASTContext &Context,
                               const TemplateArgument &X,
                               const TemplateArgument &Y) {
   if (X.getKind() != Y.getKind())
     return false;
-  
+
   switch (X.getKind()) {
     case TemplateArgument::Null:
       assert(false && "Comparing NULL template argument");
       break;
-      
+
     case TemplateArgument::Type:
       return Context.getCanonicalType(X.getAsType()) ==
              Context.getCanonicalType(Y.getAsType());
-      
+
     case TemplateArgument::Declaration:
       return X.getAsDecl()->getCanonicalDecl() ==
              Y.getAsDecl()->getCanonicalDecl();
-      
+
     case TemplateArgument::Integral:
       return *X.getAsIntegral() == *Y.getAsIntegral();
-      
+
     case TemplateArgument::Expression:
       // FIXME: We assume that all expressions are distinct, but we should
       // really check their canonical forms.
       return false;
-      
+
     case TemplateArgument::Pack:
       if (X.pack_size() != Y.pack_size())
         return false;
-      
-      for (TemplateArgument::pack_iterator XP = X.pack_begin(), 
-                                        XPEnd = X.pack_end(), 
+
+      for (TemplateArgument::pack_iterator XP = X.pack_begin(),
+                                        XPEnd = X.pack_end(),
                                            YP = Y.pack_begin();
-           XP != XPEnd; ++XP, ++YP) 
+           XP != XPEnd; ++XP, ++YP)
         if (!isSameTemplateArg(Context, *XP, *YP))
           return false;
 
@@ -899,7 +899,7 @@ static TemplateParameter makeTemplateParameter(Decl *D) {
     return TemplateParameter(TTP);
   else if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D))
     return TemplateParameter(NTTP);
-  
+
   return TemplateParameter(cast<TemplateTemplateParmDecl>(D));
 }
 
@@ -919,9 +919,9 @@ Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
   llvm::SmallVector<TemplateArgument, 4> Deduced;
   Deduced.resize(Partial->getTemplateParameters()->size());
   if (TemplateDeductionResult Result
-        = ::DeduceTemplateArguments(Context, 
+        = ::DeduceTemplateArguments(Context,
                                     Partial->getTemplateParameters(),
-                                    Partial->getTemplateArgs(), 
+                                    Partial->getTemplateArgs(),
                                     TemplateArgs, Info, Deduced))
     return Result;
 
@@ -937,11 +937,11 @@ Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
                                       Deduced.size());
   for (unsigned I = 0, N = Deduced.size(); I != N; ++I) {
     if (Deduced[I].isNull()) {
-      Decl *Param 
+      Decl *Param
         = const_cast<Decl *>(Partial->getTemplateParameters()->getParam(I));
       if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
         Info.Param = TTP;
-      else if (NonTypeTemplateParmDecl *NTTP 
+      else if (NonTypeTemplateParmDecl *NTTP
                  = dyn_cast<NonTypeTemplateParmDecl>(Param))
         Info.Param = NTTP;
       else
@@ -953,7 +953,7 @@ Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
   }
 
   // Form the template argument list from the deduced template arguments.
-  TemplateArgumentList *DeducedArgumentList 
+  TemplateArgumentList *DeducedArgumentList
     = new (Context) TemplateArgumentList(Context, Builder, /*TakeArgs=*/true);
   Info.reset(DeducedArgumentList);
 
@@ -961,45 +961,45 @@ Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
   // arguments of the class template partial specialization, and
   // verify that the instantiated template arguments are both valid
   // and are equivalent to the template arguments originally provided
-  // to the class template. 
+  // to the class template.
   ClassTemplateDecl *ClassTemplate = Partial->getSpecializedTemplate();
   const TemplateArgumentList &PartialTemplateArgs = Partial->getTemplateArgs();
   for (unsigned I = 0, N = PartialTemplateArgs.flat_size(); I != N; ++I) {
     Decl *Param = const_cast<Decl *>(
                     ClassTemplate->getTemplateParameters()->getParam(I));
-    TemplateArgument InstArg 
+    TemplateArgument InstArg
       = Subst(PartialTemplateArgs[I],
               MultiLevelTemplateArgumentList(*DeducedArgumentList));
     if (InstArg.isNull()) {
       Info.Param = makeTemplateParameter(Param);
       Info.FirstArg = PartialTemplateArgs[I];
-      return TDK_SubstitutionFailure;      
+      return TDK_SubstitutionFailure;
     }
-    
+
     if (InstArg.getKind() == TemplateArgument::Expression) {
-      // When the argument is an expression, check the expression result 
+      // When the argument is an expression, check the expression result
       // against the actual template parameter to get down to the canonical
       // template argument.
       Expr *InstExpr = InstArg.getAsExpr();
-      if (NonTypeTemplateParmDecl *NTTP 
+      if (NonTypeTemplateParmDecl *NTTP
             = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
         if (CheckTemplateArgument(NTTP, NTTP->getType(), InstExpr, InstArg)) {
           Info.Param = makeTemplateParameter(Param);
           Info.FirstArg = PartialTemplateArgs[I];
-          return TDK_SubstitutionFailure;      
+          return TDK_SubstitutionFailure;
         }
-      } else if (TemplateTemplateParmDecl *TTP 
+      } else if (TemplateTemplateParmDecl *TTP
                    = dyn_cast<TemplateTemplateParmDecl>(Param)) {
         // FIXME: template template arguments should really resolve to decls
         DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InstExpr);
         if (!DRE || CheckTemplateArgument(TTP, DRE)) {
           Info.Param = makeTemplateParameter(Param);
           Info.FirstArg = PartialTemplateArgs[I];
-          return TDK_SubstitutionFailure;      
+          return TDK_SubstitutionFailure;
         }
       }
     }
-    
+
     if (!isSameTemplateArg(Context, TemplateArgs[I], InstArg)) {
       Info.Param = makeTemplateParameter(Param);
       Info.FirstArg = TemplateArgs[I];
@@ -1016,10 +1016,10 @@ Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
 
 /// \brief Determine whether the given type T is a simple-template-id type.
 static bool isSimpleTemplateIdType(QualType T) {
-  if (const TemplateSpecializationType *Spec 
+  if (const TemplateSpecializationType *Spec
         = T->getAsTemplateSpecializationType())
     return Spec->getTemplateName().getAsTemplateDecl() != 0;
-  
+
   return false;
 }
 
@@ -1029,16 +1029,16 @@ static bool isSimpleTemplateIdType(QualType T) {
 /// \param FunctionTemplate the function template into which the explicit
 /// template arguments will be substituted.
 ///
-/// \param ExplicitTemplateArguments the explicitly-specified template 
+/// \param ExplicitTemplateArguments the explicitly-specified template
 /// arguments.
 ///
-/// \param NumExplicitTemplateArguments the number of explicitly-specified 
+/// \param NumExplicitTemplateArguments the number of explicitly-specified
 /// template arguments in @p ExplicitTemplateArguments. This value may be zero.
 ///
-/// \param Deduced the deduced template arguments, which will be populated 
+/// \param Deduced the deduced template arguments, which will be populated
 /// with the converted and checked explicit template arguments.
 ///
-/// \param ParamTypes will be populated with the instantiated function 
+/// \param ParamTypes will be populated with the instantiated function
 /// parameters.
 ///
 /// \param FunctionType if non-NULL, the result type of the function template
@@ -1071,33 +10