Remove tabs, and whitespace cleanups.

llvm-svn: 81346

1 files changed, 362 insertions, 364 deletions

diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index dc455185fec..fceac854ee8 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -27,10 +27,10 @@ using namespace clang;
 static NamedDecl *isAcceptableTemplateName(ASTContext &Context, NamedDecl *D) {
   if (!D)
     return 0;
-  
+
   if (isa<TemplateDecl>(D))
     return D;
-  
+
   if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
     // C++ [temp.local]p1:
     //   Like normal (non-template) classes, class templates have an
@@ -52,14 +52,14 @@ static NamedDecl *isAcceptableTemplateName(ASTContext &Context, NamedDecl *D) {
             = dyn_cast<ClassTemplateSpecializationDecl>(Record))
         return Spec->getSpecializedTemplate();
     }
-    
+
     return 0;
   }
-  
+
   OverloadedFunctionDecl *Ovl = dyn_cast<OverloadedFunctionDecl>(D);
   if (!Ovl)
     return 0;
-  
+
   for (OverloadedFunctionDecl::function_iterator F = Ovl->function_begin(),
                                               FEnd = Ovl->function_end();
        F != FEnd; ++F) {
@@ -71,11 +71,11 @@ static NamedDecl *isAcceptableTemplateName(ASTContext &Context, NamedDecl *D) {
         if (isa<FunctionTemplateDecl>(*F))
           break;
       }
-      
+
       if (F != FEnd) {
         // Build an overloaded function decl containing only the
         // function templates in Ovl.
-        OverloadedFunctionDecl *OvlTemplate 
+        OverloadedFunctionDecl *OvlTemplate
           = OverloadedFunctionDecl::Create(Context,
                                            Ovl->getDeclContext(),
                                            Ovl->getDeclName());
@@ -85,19 +85,19 @@ static NamedDecl *isAcceptableTemplateName(ASTContext &Context, NamedDecl *D) {
           if (isa<FunctionTemplateDecl>(*F))
             OvlTemplate->addOverload(*F);
         }
-        
+
         return OvlTemplate;
       }
 
       return FuncTmpl;
     }
   }
-  
+
   return 0;
 }
 
 TemplateNameKind Sema::isTemplateName(Scope *S,
-                                      const IdentifierInfo &II, 
+                                      const IdentifierInfo &II,
                                       SourceLocation IdLoc,
                                       const CXXScopeSpec *SS,
                                       TypeTy *ObjectTypePtr,
@@ -109,7 +109,7 @@ TemplateNameKind Sema::isTemplateName(Scope *S,
   if (ObjectTypePtr) {
     // This nested-name-specifier occurs in a member access expression, e.g.,
     // x->B::f, and we are looking into the type of the object.
-    assert((!SS || !SS->isSet()) && 
+    assert((!SS || !SS->isSet()) &&
            "ObjectType and scope specifier cannot coexist");
     QualType ObjectType = QualType::getFromOpaquePtr(ObjectTypePtr);
     LookupCtx = computeDeclContext(ObjectType);
@@ -121,29 +121,29 @@ TemplateNameKind Sema::isTemplateName(Scope *S,
     LookupCtx = computeDeclContext(*SS, EnteringContext);
     isDependent = isDependentScopeSpecifier(*SS);
   }
-  
+
   LookupResult Found;
   bool ObjectTypeSearchedInScope = false;
   if (LookupCtx) {
     // Perform "qualified" name lookup into the declaration context we
     // computed, which is either the type of the base of a member access
-    // expression or the declaration context associated with a prior 
+    // expression or the declaration context associated with a prior
     // nested-name-specifier.
 
     // The declaration context must be complete.
     if (!LookupCtx->isDependentContext() && RequireCompleteDeclContext(*SS))
       return TNK_Non_template;
-    
+
     Found = LookupQualifiedName(LookupCtx, &II, LookupOrdinaryName);
-    
+
     if (ObjectTypePtr && Found.getKind() == LookupResult::NotFound) {
       // C++ [basic.lookup.classref]p1:
       //   In a class member access expression (5.2.5), if the . or -> token is
-      //   immediately followed by an identifier followed by a <, the 
-      //   identifier must be looked up to determine whether the < is the 
+      //   immediately followed by an identifier followed by a <, the
+      //   identifier must be looked up to determine whether the < is the
       //   beginning of a template argument list (14.2) or a less-than operator.
-      //   The identifier is first looked up in the class of the object 
-      //   expression. If the identifier is not found, it is then looked up in 
+      //   The identifier is first looked up in the class of the object
+      //   expression. If the identifier is not found, it is then looked up in
       //   the context of the entire postfix-expression and shall name a class
       //   or function template.
       //
@@ -153,15 +153,15 @@ TemplateNameKind Sema::isTemplateName(Scope *S,
       ObjectTypeSearchedInScope = true;
     }
   } else if (isDependent) {
-    // We cannot look into a dependent object type or 
+    // We cannot look into a dependent object type or
     return TNK_Non_template;
   } else {
     // Perform unqualified name lookup in the current scope.
     Found = LookupName(S, &II, LookupOrdinaryName);
   }
-  
+
   // FIXME: Cope with ambiguous name-lookup results.
-  assert(!Found.isAmbiguous() && 
+  assert(!Found.isAmbiguous() &&
          "Cannot handle template name-lookup ambiguities");
 
   NamedDecl *Template = isAcceptableTemplateName(Context, Found);
@@ -170,24 +170,24 @@ TemplateNameKind Sema::isTemplateName(Scope *S,
 
   if (ObjectTypePtr && !ObjectTypeSearchedInScope) {
     // C++ [basic.lookup.classref]p1:
-    //   [...] If the lookup in the class of the object expression finds a 
+    //   [...] If the lookup in the class of the object expression finds a
     //   template, the name is also looked up in the context of the entire
     //   postfix-expression and [...]
     //
     LookupResult FoundOuter = LookupName(S, &II, LookupOrdinaryName);
     // FIXME: Handle ambiguities in this lookup better
     NamedDecl *OuterTemplate = isAcceptableTemplateName(Context, FoundOuter);
-    
+
     if (!OuterTemplate) {
-      //   - if the name is not found, the name found in the class of the 
+      //   - if the name is not found, the name found in the class of the
       //     object expression is used, otherwise
     } else if (!isa<ClassTemplateDecl>(OuterTemplate)) {
-      //   - if the name is found in the context of the entire 
-      //     postfix-expression and does not name a class template, the name 
+      //   - if the name is found in the context of the entire
+      //     postfix-expression and does not name a class template, the name
       //     found in the class of the object expression is used, otherwise
     } else {
       //   - if the name found is a class template, it must refer to the same
-      //     entity as the one found in the class of the object expression, 
+      //     entity as the one found in the class of the object expression,
       //     otherwise the program is ill-formed.
       if (OuterTemplate->getCanonicalDecl() != Template->getCanonicalDecl()) {
         Diag(IdLoc, diag::err_nested_name_member_ref_lookup_ambiguous)
@@ -195,38 +195,38 @@ TemplateNameKind Sema::isTemplateName(Scope *S,
         Diag(Template->getLocation(), diag::note_ambig_member_ref_object_type)
           << QualType::getFromOpaquePtr(ObjectTypePtr);
         Diag(OuterTemplate->getLocation(), diag::note_ambig_member_ref_scope);
-        
-        // Recover by taking the template that we found in the object 
+
+        // Recover by taking the template that we found in the object
         // expression's type.
       }
-    }      
+    }
   }
-  
+
   if (SS && SS->isSet() && !SS->isInvalid()) {
-    NestedNameSpecifier *Qualifier 
+    NestedNameSpecifier *Qualifier
       = static_cast<NestedNameSpecifier *>(SS->getScopeRep());
-    if (OverloadedFunctionDecl *Ovl 
+    if (OverloadedFunctionDecl *Ovl
           = dyn_cast<OverloadedFunctionDecl>(Template))
-      TemplateResult 
+      TemplateResult
         = TemplateTy::make(Context.getQualifiedTemplateName(Qualifier, false,
                                                             Ovl));
     else
-      TemplateResult 
+      TemplateResult
         = TemplateTy::make(Context.getQualifiedTemplateName(Qualifier, false,
-                                                 cast<TemplateDecl>(Template)));    
-  } else if (OverloadedFunctionDecl *Ovl 
+                                                 cast<TemplateDecl>(Template)));
+  } else if (OverloadedFunctionDecl *Ovl
                = dyn_cast<OverloadedFunctionDecl>(Template)) {
     TemplateResult = TemplateTy::make(TemplateName(Ovl));
   } else {
     TemplateResult = TemplateTy::make(
                                   TemplateName(cast<TemplateDecl>(Template)));
   }
-  
-  if (isa<ClassTemplateDecl>(Template) || 
+
+  if (isa<ClassTemplateDecl>(Template) ||
       isa<TemplateTemplateParmDecl>(Template))
     return TNK_Type_template;
-  
-  assert((isa<FunctionTemplateDecl>(Template) || 
+
+  assert((isa<FunctionTemplateDecl>(Template) ||
           isa<OverloadedFunctionDecl>(Template)) &&
          "Unhandled template kind in Sema::isTemplateName");
   return TNK_Function_template;
@@ -246,7 +246,7 @@ bool Sema::DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl) {
   // C++ [temp.local]p4:
   //   A template-parameter shall not be redeclared within its
   //   scope (including nested scopes).
-  Diag(Loc, diag::err_template_param_shadow) 
+  Diag(Loc, diag::err_template_param_shadow)
     << cast<NamedDecl>(PrevDecl)->getDeclName();
   Diag(PrevDecl->getLocation(), diag::note_template_param_here);
   return true;
@@ -269,24 +269,24 @@ TemplateDecl *Sema::AdjustDeclIfTemplate(DeclPtrTy &D) {
 /// (otherwise, "class" was used), and KeyLoc is the location of the
 /// "class" or "typename" keyword. ParamName is the name of the
 /// parameter (NULL indicates an unnamed template parameter) and
-/// ParamName is the location of the parameter name (if any). 
+/// ParamName is the location of the parameter name (if any).
 /// If the type parameter has a default argument, it will be added
 /// later via ActOnTypeParameterDefault.
-Sema::DeclPtrTy Sema::ActOnTypeParameter(Scope *S, bool Typename, bool Ellipsis, 
+Sema::DeclPtrTy Sema::ActOnTypeParameter(Scope *S, bool Typename, bool Ellipsis,
                                          SourceLocation EllipsisLoc,
                                          SourceLocation KeyLoc,
                                          IdentifierInfo *ParamName,
                                          SourceLocation ParamNameLoc,
                                          unsigned Depth, unsigned Position) {
-  assert(S->isTemplateParamScope() && 
-	 "Template type parameter not in template parameter scope!");
+  assert(S->isTemplateParamScope() &&
+         "Template type parameter not in template parameter scope!");
   bool Invalid = false;
 
   if (ParamName) {
     NamedDecl *PrevDecl = LookupName(S, ParamName, LookupTagName);
     if (PrevDecl && PrevDecl->isTemplateParameter())
       Invalid = Invalid || DiagnoseTemplateParameterShadow(ParamNameLoc,
-							   PrevDecl);
+                                                           PrevDecl);
   }
 
   SourceLocation Loc = ParamNameLoc;
@@ -294,8 +294,8 @@ Sema::DeclPtrTy Sema::ActOnTypeParameter(Scope *S, bool Typename, bool Ellipsis,
     Loc = KeyLoc;
 
   TemplateTypeParmDecl *Param
-    = TemplateTypeParmDecl::Create(Context, CurContext, Loc, 
-                                   Depth, Position, ParamName, Typename, 
+    = TemplateTypeParmDecl::Create(Context, CurContext, Loc,
+                                   Depth, Position, ParamName, Typename,
                                    Ellipsis);
   if (Invalid)
     Param->setInvalidDecl();
@@ -310,28 +310,28 @@ Sema::DeclPtrTy Sema::ActOnTypeParameter(Scope *S, bool Typename, bool Ellipsis,
 }
 
 /// ActOnTypeParameterDefault - Adds a default argument (the type
-/// Default) to the given template type parameter (TypeParam). 
-void Sema::ActOnTypeParameterDefault(DeclPtrTy TypeParam, 
+/// Default) to the given template type parameter (TypeParam).
+void Sema::ActOnTypeParameterDefault(DeclPtrTy TypeParam,
                                      SourceLocation EqualLoc,
-                                     SourceLocation DefaultLoc, 
+                                     SourceLocation DefaultLoc,
                                      TypeTy *DefaultT) {
-  TemplateTypeParmDecl *Parm 
+  TemplateTypeParmDecl *Parm
     = cast<TemplateTypeParmDecl>(TypeParam.getAs<Decl>());
   // FIXME: Preserve type source info.
   QualType Default = GetTypeFromParser(DefaultT);
 
   // C++0x [temp.param]p9:
   // A default template-argument may be specified for any kind of
-  // template-parameter that is not a template parameter pack.  
+  // template-parameter that is not a template parameter pack.
   if (Parm->isParameterPack()) {
     Diag(DefaultLoc, diag::err_template_param_pack_default_arg);
     return;
   }
-  
+
   // C++ [temp.param]p14:
   //   A template-parameter shall not be used in its own default argument.
   // FIXME: Implement this check! Needs a recursive walk over the types.
-  
+
   // Check the template argument itself.
   if (CheckTemplateArgument(Parm, Default, DefaultLoc)) {
     Parm->setInvalidDecl();
@@ -346,7 +346,7 @@ void Sema::ActOnTypeParameterDefault(DeclPtrTy TypeParam,
 ///
 /// \returns the (possibly-promoted) parameter type if valid;
 /// otherwise, produces a diagnostic and returns a NULL type.
-QualType 
+QualType
 Sema::CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc) {
   // C++ [temp.param]p4:
   //
@@ -355,11 +355,11 @@ Sema::CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc) {
   //
   //       -- integral or enumeration type,
   if (T->isIntegralType() || T->isEnumeralType() ||
-      //   -- pointer to object or pointer to function, 
-      (T->isPointerType() && 
+      //   -- pointer to object or pointer to function,
+      (T->isPointerType() &&
        (T->getAs<PointerType>()->getPointeeType()->isObjectType() ||
         T->getAs<PointerType>()->getPointeeType()->isFunctionType())) ||
-      //   -- reference to object or reference to function, 
+      //   -- reference to object or reference to function,
       T->isReferenceType() ||
       //   -- pointer to member.
       T->isMemberPointerType() ||
@@ -390,7 +390,7 @@ Sema::CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc) {
 /// class Array") has been parsed. S is the current scope and D is
 /// the parsed declarator.
 Sema::DeclPtrTy Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
-                                                    unsigned Depth, 
+                                                    unsigned Depth,
                                                     unsigned Position) {
   DeclaratorInfo *DInfo = 0;
   QualType T = GetTypeForDeclarator(D, S, &DInfo);
@@ -432,14 +432,14 @@ Sema::DeclPtrTy Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
 void Sema::ActOnNonTypeTemplateParameterDefault(DeclPtrTy TemplateParamD,
                                                 SourceLocation EqualLoc,
                                                 ExprArg DefaultE) {
-  NonTypeTemplateParmDecl *TemplateParm 
+  NonTypeTemplateParmDecl *TemplateParm
     = cast<NonTypeTemplateParmDecl>(TemplateParamD.getAs<Decl>());
   Expr *Default = static_cast<Expr *>(DefaultE.get());
-  
+
   // C++ [temp.param]p14:
   //   A template-parameter shall not be used in its own default argument.
   // FIXME: Implement this check! Needs a recursive walk over the types.
-  
+
   // Check the well-formedness of the default template argument.
   TemplateArgument Converted;
   if (CheckTemplateArgument(TemplateParm, TemplateParm->getType(), Default,
@@ -461,8 +461,7 @@ Sema::DeclPtrTy Sema::ActOnTemplateTemplateParameter(Scope* S,
                                                      IdentifierInfo *Name,
                                                      SourceLocation NameLoc,
                                                      unsigned Depth,
-                                                     unsigned Position)
-{
+                                                     unsigned Position) {
   assert(S->isTemplateParamScope() &&
          "Template template parameter not in template parameter scope!");
 
@@ -496,12 +495,12 @@ Sema::DeclPtrTy Sema::ActOnTemplateTemplateParameter(Scope* S,
 void Sema::ActOnTemplateTemplateParameterDefault(DeclPtrTy TemplateParamD,
                                                  SourceLocation EqualLoc,
                                                  ExprArg DefaultE) {
-  TemplateTemplateParmDecl *TemplateParm 
+  TemplateTemplateParmDecl *TemplateParm
     = cast<TemplateTemplateParmDecl>(TemplateParamD.getAs<Decl>());
 
   // Since a template-template parameter's default argument is an
   // id-expression, it must be a DeclRefExpr.
-  DeclRefExpr *Default 
+  DeclRefExpr *Default
     = cast<DeclRefExpr>(static_cast<Expr *>(DefaultE.get()));
 
   // C++ [temp.param]p14:
@@ -510,12 +509,12 @@ void Sema::ActOnTemplateTemplateParameterDefault(DeclPtrTy TemplateParamD,
 
   // Check the well-formedness of the template argument.
   if (!isa<TemplateDecl>(Default->getDecl())) {
-    Diag(Default->getSourceRange().getBegin(), 
+    Diag(Default->getSourceRange().getBegin(),
          diag::err_template_arg_must_be_template)
       << Default->getSourceRange();
     TemplateParm->setInvalidDecl();
     return;
-  } 
+  }
   if (CheckTemplateArgument(TemplateParm, Default)) {
     TemplateParm->setInvalidDecl();
     return;
@@ -530,7 +529,7 @@ void Sema::ActOnTemplateTemplateParameterDefault(DeclPtrTy TemplateParamD,
 Sema::TemplateParamsTy *
 Sema::ActOnTemplateParameterList(unsigned Depth,
                                  SourceLocation ExportLoc,
-                                 SourceLocation TemplateLoc, 
+                                 SourceLocation TemplateLoc,
                                  SourceLocation LAngleLoc,
                                  DeclPtrTy *Params, unsigned NumParams,
                                  SourceLocation RAngleLoc) {
@@ -548,7 +547,7 @@ Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
                          AttributeList *Attr,
                          TemplateParameterList *TemplateParams,
                          AccessSpecifier AS) {
-  assert(TemplateParams && TemplateParams->size() > 0 && 
+  assert(TemplateParams && TemplateParams->size() > 0 &&
          "No template parameters");
   assert(TUK != TUK_Reference && "Can only declare or define class templates");
   bool Invalid = false;
@@ -580,14 +579,14 @@ Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
       // FIXME: Produce a reasonable diagnostic here
       return true;
     }
-    
-    Previous = LookupQualifiedName(SemanticContext, Name, LookupOrdinaryName, 
+
+    Previous = LookupQualifiedName(SemanticContext, Name, LookupOrdinaryName,
                                    true);
   } else {
     SemanticContext = CurContext;
     Previous = LookupName(S, Name, LookupOrdinaryName, true);
   }
-  
+
   assert(!Previous.isAmbiguous() && "Ambiguity in class template redecl?");
   NamedDecl *PrevDecl = 0;
   if (Previous.begin() != Previous.end())
@@ -595,10 +594,10 @@ Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
 
   if (PrevDecl && !isDeclInScope(PrevDecl, SemanticContext, S))
     PrevDecl = 0;
-  
+
   // If there is a previous declaration with the same name, check
   // whether this is a valid redeclaration.
-  ClassTemplateDecl *PrevClassTemplate 
+  ClassTemplateDecl *PrevClassTemplate
     = dyn_cast_or_null<ClassTemplateDecl>(PrevDecl);
   if (PrevClassTemplate) {
     // Ensure that the template parameter lists are compatible.
@@ -614,9 +613,9 @@ Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
     //   template declaration (7.1.5.3).
     RecordDecl *PrevRecordDecl = PrevClassTemplate->getTemplatedDecl();
     if (!isAcceptableTagRedeclaration(PrevRecordDecl, Kind, KWLoc, *Name)) {
-      Diag(KWLoc, diag::err_use_with_wrong_tag) 
+      Diag(KWLoc, diag::err_use_with_wrong_tag)
         << Name
-        << CodeModificationHint::CreateReplacement(KWLoc, 
+        << CodeModificationHint::CreateReplacement(KWLoc,
                             PrevRecordDecl->getKindName());
       Diag(PrevRecordDecl->getLocation(), diag::note_previous_use);
       Kind = PrevRecordDecl->getTagKind();
@@ -654,13 +653,13 @@ Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
   if (CheckTemplateParameterList(TemplateParams,
             PrevClassTemplate? PrevClassTemplate->getTemplateParameters() : 0))
     Invalid = true;
-    
+
   // FIXME: If we had a scope specifier, we better have a previous template
   // declaration!
 
-  CXXRecordDecl *NewClass = 
+  CXXRecordDecl *NewClass =
     CXXRecordDecl::Create(Context, Kind, SemanticContext, NameLoc, Name, KWLoc,
-                          PrevClassTemplate? 
+                          PrevClassTemplate?
                             PrevClassTemplate->getTemplatedDecl() : 0,
                           /*DelayTypeCreation=*/true);
 
@@ -671,16 +670,16 @@ Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
   NewClass->setDescribedClassTemplate(NewTemplate);
 
   // Build the type for the class template declaration now.
-  QualType T = 
-    Context.getTypeDeclType(NewClass, 
-                            PrevClassTemplate? 
-                              PrevClassTemplate->getTemplatedDecl() : 0);  
+  QualType T =
+    Context.getTypeDeclType(NewClass,
+                            PrevClassTemplate?
+                              PrevClassTemplate->getTemplatedDecl() : 0);
   assert(T->isDependentType() && "Class template type is not dependent?");
   (void)T;
 
   // Set the access specifier.
   SetMemberAccessSpecifier(NewTemplate, PrevClassTemplate, AS);
-  
+
   // Set the lexical context of these templates
   NewClass->setLexicalDeclContext(CurContext);
   NewTemplate->setLexicalDeclContext(CurContext);
@@ -722,7 +721,7 @@ Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
 bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams,
                                       TemplateParameterList *OldParams) {
   bool Invalid = false;
-  
+
   // C++ [temp.param]p10:
   //   The set of default template-arguments available for use with a
   //   template declaration or definition is obtained by merging the
@@ -755,7 +754,7 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams,
     // If a template parameter of a class template is a template parameter pack,
     // it must be the last template parameter.
     if (SawParameterPack) {
-      Diag(ParameterPackLoc, 
+      Diag(ParameterPackLoc,
            diag::err_template_param_pack_must_be_last_template_parameter);
       Invalid = true;
     }
@@ -763,15 +762,15 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams,
     // Merge default arguments for template type parameters.
     if (TemplateTypeParmDecl *NewTypeParm
           = dyn_cast<TemplateTypeParmDecl>(*NewParam)) {
-      TemplateTypeParmDecl *OldTypeParm 
+      TemplateTypeParmDecl *OldTypeParm
           = OldParams? cast<TemplateTypeParmDecl>(*OldParam) : 0;
-      
+
       if (NewTypeParm->isParameterPack()) {
         assert(!NewTypeParm->hasDefaultArgument() &&
                "Parameter packs can't have a default argument!");
         SawParameterPack = true;
         ParameterPackLoc = NewTypeParm->getLocation();
-      } else if (OldTypeParm && OldTypeParm->hasDefaultArgument() && 
+      } else if (OldTypeParm && OldTypeParm->hasDefaultArgument() &&
           NewTypeParm->hasDefaultArgument()) {
         OldDefaultLoc = OldTypeParm->getDefaultArgumentLoc();
         NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc();
@@ -796,7 +795,7 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams,
       // Merge default arguments for non-type template parameters
       NonTypeTemplateParmDecl *OldNonTypeParm
         = OldParams? cast<NonTypeTemplateParmDecl>(*OldParam) : 0;
-      if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument() && 
+      if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument() &&
           NewNonTypeParm->hasDefaultArgument()) {
         OldDefaultLoc = OldNonTypeParm->getDefaultArgumentLoc();
         NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc();
@@ -817,14 +816,14 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams,
         SawDefaultArgument = true;
         PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc();
       } else if (SawDefaultArgument)
-        MissingDefaultArg = true;      
+        MissingDefaultArg = true;
     } else {
     // Merge default arguments for template template parameters
       TemplateTemplateParmDecl *NewTemplateParm
         = cast<TemplateTemplateParmDecl>(*NewParam);
       TemplateTemplateParmDecl *OldTemplateParm
         = OldParams? cast<TemplateTemplateParmDecl>(*OldParam) : 0;
-      if (OldTemplateParm && OldTemplateParm->hasDefaultArgument() && 
+      if (OldTemplateParm && OldTemplateParm->hasDefaultArgument() &&
           NewTemplateParm->hasDefaultArgument()) {
         OldDefaultLoc = OldTemplateParm->getDefaultArgumentLoc();
         NewDefaultLoc = NewTemplateParm->getDefaultArgumentLoc();
@@ -844,7 +843,7 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams,
         SawDefaultArgument = true;
         PreviousDefaultArgLoc = NewTemplateParm->getDefaultArgumentLoc();
       } else if (SawDefaultArgument)
-        MissingDefaultArg = true;      
+        MissingDefaultArg = true;
     }
 
     if (RedundantDefaultArg) {
@@ -859,7 +858,7 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams,
       //   If a template-parameter has a default template-argument,
       //   all subsequent template-parameters shall have a default
       //   template-argument supplied.
-      Diag((*NewParam)->getLocation(), 
+      Diag((*NewParam)->getLocation(),
            diag::err_template_param_default_arg_missing);
       Diag(PreviousDefaultArgLoc, diag::note_template_param_prev_default_arg);
       Invalid = true;
@@ -874,13 +873,13 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams,
   return Invalid;
 }
 
-/// \brief Match the given template parameter lists to the given scope 
+/// \brief Match the given template parameter lists to the given scope
 /// specifier, returning the template parameter list that applies to the
 /// name.
 ///
 /// \param DeclStartLoc the start of the declaration that has a scope
 /// specifier or a template parameter list.
-/// 
+///
 /// \param SS the scope specifier that will be matched to the given template
 /// parameter lists. This scope specifier precedes a qualified name that is
 /// being declared.
@@ -890,10 +889,10 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams,
 ///
 /// \param NumParamLists the number of template parameter lists in ParamLists.
 ///
-/// \returns the template parameter list, if any, that corresponds to the 
+/// \returns the template parameter list, if any, that corresponds to the
 /// name that is preceded by the scope specifier @p SS. This template
 /// parameter list may be have template parameters (if we're declaring a
-/// template) or may have no template parameters (if we're declaring a 
+/// template) or may have no template parameters (if we're declaring a
 /// template specialization), or may be NULL (if we were's declaring isn't
 /// itself a template).
 TemplateParameterList *
@@ -907,35 +906,35 @@ Sema::MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc,
     TemplateIdsInSpecifier;
   for (NestedNameSpecifier *NNS = (NestedNameSpecifier *)SS.getScopeRep();
        NNS; NNS = NNS->getPrefix()) {
-    if (const TemplateSpecializationType *SpecType 
+    if (const TemplateSpecializationType *SpecType
           = dyn_cast_or_null<TemplateSpecializationType>(NNS->getAsType())) {
       TemplateDecl *Template = SpecType->getTemplateName().getAsTemplateDecl();
       if (!Template)
         continue; // FIXME: should this be an error? probably...
-   
+
       if (const RecordType *Record = SpecType->getAs<RecordType>()) {
         ClassTemplateSpecializationDecl *SpecDecl
           = cast<ClassTemplateSpecializationDecl>(Record->getDecl());
         // If the nested name specifier refers to an explicit specialization,
         // we don't need a template<> header.
-        // FIXME: revisit this approach once we cope with specialization 
+        // FIXME: revisit this approach once we cope with specialization
         // properly.
         if (SpecDecl->getSpecializationKind() == TSK_ExplicitSpecialization)
           continue;
       }
-      
+
       TemplateIdsInSpecifier.push_back(SpecType);
     }
   }
-  
+
   // Reverse the list of template-ids in the scope specifier, so that we can
   // more easily match up the template-ids and the template parameter lists.
   std::reverse(TemplateIdsInSpecifier.begin(), TemplateIdsInSpecifier.end());
-  
+
   SourceLocation FirstTemplateLoc = DeclStartLoc;
   if (NumParamLists)
     FirstTemplateLoc = ParamLists[0]->getTemplateLoc();
-      
+
   // Match the template-ids found in the specifier to the template parameter
   // lists.
   unsigned Idx = 0;
@@ -947,8 +946,8 @@ Sema::MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc,
       // We have a template-id without a corresponding template parameter
       // list.
       if (DependentTemplateId) {
-        // FIXME: the location information here isn't great. 
-        Diag(SS.getRange().getBegin(), 
+        // FIXME: the location information here isn't great.
+        Diag(SS.getRange().getBegin(),
              diag::err_template_spec_needs_template_parameters)
           << TemplateId
           << SS.getRange();
@@ -960,13 +959,13 @@ Sema::MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc,
       }
       return 0;
     }
-    
+
     // Check the template parameter list against its corresponding template-id.
     if (DependentTemplateId) {
-      TemplateDecl *Template 
+      TemplateDecl *Template
         = TemplateIdsInSpecifier[Idx]->getTemplateName().getAsTemplateDecl();
 
-      if (ClassTemplateDecl *ClassTemplate 
+      if (ClassTemplateDecl *ClassTemplate
             = dyn_cast<ClassTemplateDecl>(Template)) {
         TemplateParameterList *ExpectedTemplateParams = 0;
         // Is this template-id naming the primary template?
@@ -979,34 +978,34 @@ Sema::MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc,
           ExpectedTemplateParams = PartialSpec->getTemplateParameters();
 
         if (ExpectedTemplateParams)
-          TemplateParameterListsAreEqual(ParamLists[Idx], 
+          TemplateParameterListsAreEqual(ParamLists[Idx],
                                          ExpectedTemplateParams,
                                          true);
-      } 
+      }
     } else if (ParamLists[Idx]->size() > 0)
-      Diag(ParamLists[Idx]->getTemplateLoc(), 
+      Diag(ParamLists[Idx]->getTemplateLoc(),
            diag::err_template_param_list_matches_nontemplate)
         << TemplateId
         << ParamLists[Idx]->getSourceRange();
   }
-  
+
   // If there were at least as many template-ids as there were template
   // parameter lists, then there are no template parameter lists remaining for
   // the declaration itself.
   if (Idx >= NumParamLists)
     return 0;
-  
+
   // If there were too many template parameter lists, complain about that now.
   if (Idx != NumParamLists - 1) {
     while (Idx < NumParamLists - 1) {
-      Diag(ParamLists[Idx]->getTemplateLoc(), 
+      Diag(ParamLists[Idx]->getTemplateLoc(),
            diag::err_template_spec_extra_headers)
         << SourceRange(ParamLists[Idx]->getTemplateLoc(),
                        ParamLists[Idx]->getRAngleLoc());
       ++Idx;
     }
   }
-  
+
   // Return the last template parameter list, which corresponds to the
   // entity being declared.
   return ParamLists[NumParamLists - 1];
@@ -1014,8 +1013,8 @@ Sema::MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc,
 
 /// \brief Translates template arguments as provided by the parser
 /// into template arguments used by semantic analysis.
-static void 
-translateTemplateArguments(ASTTemplateArgsPtr &TemplateArgsIn, 
+static void
+translateTemplateArguments(ASTTemplateArgsPtr &TemplateArgsIn,
                            SourceLocation *TemplateArgLocs,
                      llvm::SmallVector<TemplateArgument, 16> &TemplateArgs) {
   TemplateArgs.reserve(TemplateArgsIn.size());
@@ -1049,12 +1048,12 @@ QualType Sema::CheckTemplateIdType(TemplateName Name,
   // template.
   TemplateArgumentListBuilder Converted(Template->getTemplateParameters(),
                                         NumTemplateArgs);
-  if (CheckTemplateArgumentList(Template, TemplateLoc, LAngleLoc, 
+  if (CheckTemplateArgumentList(Template, TemplateLoc, LAngleLoc,
                                 TemplateArgs, NumTemplateArgs, RAngleLoc,
                                 false, Converted))
     return QualType();
 
-  assert((Converted.structuredSize() == 
+  assert((Converted.structuredSize() ==
             Template->getTemplateParameters()->size()) &&
          "Converted template argument list is too short!");
 
@@ -1071,21 +1070,21 @@ QualType Sema::CheckTemplateIdType(TemplateName Name,
     //
     //   template<typename T, typename U = T> struct A;
     TemplateName CanonName = Context.getCanonicalTemplateName(Name);
-    CanonType = Context.getTemplateSpecializationType(CanonName, 
+    CanonType = Context.getTemplateSpecializationType(CanonName,
                                                    Converted.getFlatArguments(),
                                                    Converted.flatSize());
-    
+
     // FIXME: CanonType is not actually the canonical type, and unfortunately
     // it is a TemplateTypeSpecializationType that we will never use again.
     // In the future, we need to teach getTemplateSpecializationType to only
     // build the canonical type and return that to us.
     CanonType = Context.getCanonicalType(CanonType);
-  } else if (ClassTemplateDecl *ClassTemplate 
+  } else if (ClassTemplateDecl *ClassTemplate
                = dyn_cast<ClassTemplateDecl>(Template)) {
     // Find the class template specialization declaration that
     // corresponds to these arguments.
     llvm::FoldingSetNodeID ID;
-    ClassTemplateSpecializationDecl::Profile(ID, 
+    ClassTemplateSpecializationDecl::Profile(ID,
                                              Converted.getFlatArguments(),
                                              Converted.flatSize(),
                                              Context);
@@ -1096,7 +1095,7 @@ QualType Sema::CheckTemplateIdType(TemplateName Name,
       // This is the first time we have referenced this class template
       // specialization. Create the canonical declaration and add it to
       // the set of specializations.
-      Decl = ClassTemplateSpecializationDecl::Create(Context, 
+      Decl = ClassTemplateSpecializationDecl::Create(Context,
                                     ClassTemplate->getDeclContext(),
                                     TemplateLoc,
                                     ClassTemplate,
@@ -1107,7 +1106,7 @@ QualType Sema::CheckTemplateIdType(TemplateName Name,
 
     CanonType = Context.getTypeDeclType(Decl);
   }
-  
+
   // Build the fully-sugared type for this class template
   // specialization, which refers back to the class template
   // specialization we created or found.
@@ -1118,7 +1117,7 @@ QualType Sema::CheckTemplateIdType(TemplateName Name,
 
 Action::TypeResult
 Sema::ActOnTemplateIdType(TemplateTy TemplateD, SourceLocation TemplateLoc,
-                          SourceLocation LAngleLoc, 
+                          SourceLocation LAngleLoc,
                           ASTTemplateArgsPtr TemplateArgsIn,
                           SourceLocation *TemplateArgLocs,
                           SourceLocation RAngleLoc) {
@@ -1151,7 +1150,7 @@ Sema::TypeResult Sema::ActOnTagTemplateIdType(TypeResult TypeResult,
 
   // Verify the tag specifier.
   TagDecl::TagKind TagKind = TagDecl::getTagKindForTypeSpec(TagSpec);
-  
+
   if (const RecordType *RT = Type->getAs<RecordType>()) {
     RecordDecl *D = RT->getDecl();
 
@@ -1179,14 +1178,14 @@ Sema::OwningExprResult Sema::BuildTemplateIdExpr(TemplateName Template,
                                                  SourceLocation RAngleLoc) {
   // FIXME: Can we do any checking at this point? I guess we could check the
   // template arguments that we have against the template name, if the template
-  // name refers to a single template. That's not a terribly common case, 
+  // name refers to a single template. That's not a terribly common case,
   // though.
-  return Owned(TemplateIdRefExpr::Create(Context, 
+  return Owned(TemplateIdRefExpr::Create(Context,
                                          /*FIXME: New type?*/Context.OverloadTy,
                                          /*FIXME: Necessary?*/0,
                                          /*FIXME: Necessary?*/SourceRange(),
                                          Template, TemplateNameLoc, LAngleLoc,
-                                         TemplateArgs, 
+                                         TemplateArgs,
                                          NumTemplateArgs, RAngleLoc));
 }
 
@@ -1197,12 +1196,12 @@ Sema::OwningExprResult Sema::ActOnTemplateIdExpr(TemplateTy TemplateD,
                                                 SourceLocation *TemplateArgLocs,
                                                  SourceLocation RAngleLoc) {
   TemplateName Template = TemplateD.getAsVal<TemplateName>();
-  
+
   // Translate the parser's template argument list in our AST format.
   llvm::SmallVector<TemplateArgument, 16> TemplateArgs;
   translateTemplateArguments(TemplateArgsIn, TemplateArgLocs, TemplateArgs);
   TemplateArgsIn.release();
-  
+
   return BuildTemplateIdExpr(Template, TemplateNameLoc, LAngleLoc,
                              TemplateArgs.data(), TemplateArgs.size(),
                              RAngleLoc);
@@ -1220,7 +1219,7 @@ Sema::ActOnMemberTemplateIdReferenceExpr(Scope *S, ExprArg Base,
                                          SourceLocation *TemplateArgLocs,
                                          SourceLocation RAngleLoc) {
   TemplateName Template = TemplateD.getAsVal<TemplateName>();
-  
+
   // FIXME: We're going to end up looking up the template based on its name,
   // twice!
   DeclarationName Name;
@@ -1230,17 +1229,17 @@ Sema::ActOnMemberTemplateIdReferenceExpr(Scope *S, ExprArg Base,
     Name = Ovl->getDeclName();
   else
     Name = Template.getAsDependentTemplateName()->getName();
-  
+
   // Translate the parser's template argument list in our AST format.
   llvm::SmallVector<TemplateArgument, 16> TemplateArgs;
   translateTemplateArguments(TemplateArgsIn, TemplateArgLocs, TemplateArgs);
   TemplateArgsIn.release();
-  
+
   // Do we have the save the actual template name? We might need it...
   return BuildMemberReferenceExpr(S, move(Base), OpLoc, OpKind, TemplateNameLoc,
                                   Name, true, LAngleLoc,
                                   TemplateArgs.data(), TemplateArgs.size(),
-                                  RAngleLoc, DeclPtrTy(), &SS);  
+                                  RAngleLoc, DeclPtrTy(), &SS);
 }
 
 /// \brief Form a dependent template name.
@@ -1250,13 +1249,13 @@ Sema::ActOnMemberTemplateIdReferenceExpr(Scope *S, ExprArg Base,
 /// example, given "MetaFun::template apply", the scope specifier \p
 /// SS will be "MetaFun::", \p TemplateKWLoc contains the location
 /// of the "template" keyword, and "apply" is the \p Name.
-Sema::TemplateTy 
+Sema::TemplateTy
 Sema::ActOnDependentTemplateName(SourceLocation TemplateKWLoc,
                                  const IdentifierInfo &Name,
                                  SourceLocation NameLoc,
                                  const CXXScopeSpec &SS,
                                  TypeTy *ObjectType) {
-  if ((ObjectType && 
+  if ((ObjectType &&
        computeDeclContext(QualType::getFromOpaquePtr(ObjectType))) ||
       (SS.isSet() && computeDeclContext(SS, false))) {
     // C++0x [temp.names]p5:
@@ -1276,7 +1275,7 @@ Sema::ActOnDependentTemplateName(SourceLocation TemplateKWLoc,
     // "template" keyword is now permitted). We follow the C++0x
     // rules, even in C++03 mode, retroactively applying the DR.
     TemplateTy Template;
-    TemplateNameKind TNK = isTemplateName(0, Name, NameLoc, &SS, ObjectType, 
+    TemplateNameKind TNK = isTemplateName(0, Name, NameLoc, &SS, ObjectType,
                                           false, Template);
     if (TNK == TNK_Non_template) {
       Diag(NameLoc, diag::err_template_kw_refers_to_non_template)
@@ -1287,12 +1286,12 @@ Sema::ActOnDependentTemplateName(SourceLocation TemplateKWLoc,
     return Template;
   }
 
-  NestedNameSpecifier *Qualifier 
+  NestedNameSpecifier *Qualifier
     = static_cast<NestedNameSpecifier *>(SS.getScopeRep());
   return TemplateTy::make(Context.getDependentTemplateName(Qualifier, &Name));
 }
 
-bool Sema::CheckTemplateTypeArgument(TemplateTypeParmDecl *Param, 
+bool Sema::CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
                                      const TemplateArgument &Arg,
                                      TemplateArgumentListBuilder &Converted) {
   // Check template type parameter.
@@ -1305,13 +1304,13 @@ bool Sema::CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
     // is not a type.
     Diag(Arg.getLocation(), diag::err_template_arg_must_be_type);
     Diag(Param->getLocation(), diag::note_template_param_here);
-    
+
     return true;
-  }    
+  }
 
   if (CheckTemplateArgument(Param, Arg.getAsType(), Arg.getLocation()))
     return true;
-  
+
   // Add the converted template type argument.
   Converted.Append(
                  TemplateArgument(Arg.getLocation(),
@@ -1334,9 +1333,9 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template,
   unsigned NumArgs = NumTemplateArgs;
   bool Invalid = false;
 
-  bool HasParameterPack = 
+  bool HasParameterPack =
     NumParams > 0 && Params->getParam(NumParams - 1)->isTemplateParameterPack();
-  
+
   if ((NumArgs > NumParams && !HasParameterPack) ||
       (NumArgs < Params->getMinRequiredArguments() &&
        !PartialTemplateArgs)) {
@@ -1356,8 +1355,8 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template,
       << Params->getSourceRange();
     Invalid = true;
   }
-  
-  // C++ [temp.arg]p1: 
+
+  // C++ [temp.arg]p1:
   //   [...] The type and form of each template-argument specified in
   //   a template-id shall match the type and form specified for the
   //   corresponding parameter declared by the template in its
@@ -1368,7 +1367,7 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template,
        Param != ParamEnd; ++Param, ++ArgIdx) {
     if (ArgIdx > NumArgs && PartialTemplateArgs)
       break;
-    
+
     // Decode the template argument
     TemplateArgument Arg;
     if (ArgIdx >= NumArgs) {
@@ -1381,7 +1380,7 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template,
           Converted.EndPack();
           break;
         }
-        
+
         if (!TTP->hasDefaultArgument())
           break;
 
@@ -1390,14 +1389,14 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template,
         // If the argument type is dependent, instantiate it now based
         // on the previously-computed template arguments.
         if (ArgType->isDependentType()) {
-          InstantiatingTemplate Inst(*this, TemplateLoc, 
+          InstantiatingTemplate Inst(*this, TemplateLoc,
                                      Template, Converted.getFlatArguments(),
                                      Converted.flatSize(),
                                      SourceRange(TemplateLoc, RAngleLoc));
 
           TemplateArgumentList TemplateArgs(Context, Converted,
                                             /*TakeArgs=*/false);
-          ArgType = SubstType(ArgType, 
+          ArgType = SubstType(ArgType,
                               MultiLevelTemplateArgumentList(TemplateArgs),
                               TTP->getDefaultArgumentLoc(),
                               TTP->getDeclName());
@@ -1407,29 +1406,29 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template,
           return true;
 
         Arg = TemplateArgument(TTP->getLocation(), ArgType);
-      } else if (NonTypeTemplateParmDecl *NTTP 
+      } else if (NonTypeTemplateParmDecl *NTTP
                    = dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
         if (!NTTP->hasDefaultArgument())
           break;
 
-        InstantiatingTemplate Inst(*this, TemplateLoc, 
+        InstantiatingTemplate Inst(*this, TemplateLoc,
                                    Template, Converted.getFlatArguments(),
                                    Converted.flatSize(),
                                    SourceRange(TemplateLoc, RAngleLoc));
-        
+
         TemplateArgumentList TemplateArgs(Context, Converted,
                                           /*TakeArgs=*/false);
 
-        Sema::OwningExprResult E 
-          = SubstExpr(NTTP->getDefaultArgument(), 
+        Sema::OwningExprResult E
+          = SubstExpr(NTTP->getDefaultArgument(),
                       MultiLevelTemplateArgumentList(TemplateArgs));
         if (E.isInvalid())
           return true;
-        
+
         Arg = TemplateArgument(E.takeAs<Expr>());
       } else {
-        TemplateTemplateParmDecl *TempParm 
-          = cast<TemplateTemplateParmDecl>(*Param);      
+        TemplateTemplateParmDecl *TempParm
+          = cast<TemplateTemplateParmDecl>(*Param);
 
         if (!TempParm->hasDefaultArgument())
           break;
@@ -1451,13 +1450,13 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template,
           if (CheckTemplateTypeArgument(TTP, TemplateArgs[ArgIdx], Converted))
             Invalid = true;
         }
-        
+
         Converted.EndPack();
       } else {
         if (CheckTemplateTypeArgument(TTP, Arg, Converted))
           Invalid = true;
       }
-    } else if (NonTypeTemplateParmDecl *NTTP 
+    } else if (NonTypeTemplateParmDecl *NTTP
                  = dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
       // Check non-type template parameters.
 
@@ -1466,21 +1465,21 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template,
       QualType NTTPType = NTTP->getType();
       if (NTTPType->isDependentType()) {
         // Do substitution on the type of the non-type template parameter.
-        InstantiatingTemplate Inst(*this, TemplateLoc, 
+        InstantiatingTemplate Inst(*this, TemplateLoc,
                                    Template, Converted.getFlatArguments(),
                                    Converted.flatSize(),
                                    SourceRange(TemplateLoc, RAngleLoc));
 
         TemplateArgumentList TemplateArgs(Context, Converted,
                                           /*TakeArgs=*/false);
-        NTTPType = SubstType(NTTPType, 
+        NTTPType = SubstType(NTTPType,
                              MultiLevelTemplateArgumentList(TemplateArgs),
                              NTTP->getLocation(),
                              NTTP->getDeclName());
         // If that worked, check the non-type template parameter type
         // for validity.
         if (!NTTPType.isNull())
-          NTTPType = CheckNonTypeTemplateParameterType(NTTPType, 
+          NTTPType = CheckNonTypeTemplateParameterType(NTTPType,
                                                        NTTP->getLocation());
         if (NTTPType.isNull()) {
           Invalid = true;
@@ -1492,7 +1491,7 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template,
       case TemplateArgument::Null:
         assert(false && "Should never see a NULL template argument here");
         break;
-          
+
       case TemplateArgument::Expression: {
         Expr *E = Arg.getAsExpr();
         TemplateArgument Result;
@@ -1513,7 +1512,7 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template,
       case TemplateArgument::Type:
         // We have a non-type template parameter but the template
         // argument is a type.
-        
+
         // C++ [temp.arg]p2:
         //   In a template-argument, an ambiguity between a type-id and
         //   an expression is resolved to a type-id, regardless of the
@@ -1529,37 +1528,37 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template,
         Diag((*Param)->getLocation(), diag::note_template_param_here);
         Invalid = true;
         break;
-      
+
       case TemplateArgument::Pack:
         assert(0 && "FIXME: Implement!");
         break;
       }
-    } else { 
+    } else {
       // Check template template parameters.
-      TemplateTemplateParmDecl *TempParm 
+      TemplateTemplateParmDecl *TempParm
         = cast<TemplateTemplateParmDecl>(*Param);
-     
+
       switch (Arg.getKind()) {
       case TemplateArgument::Null:
         assert(false && "Should never see a NULL template argument here");
         break;
-          
+
       case TemplateArgument::Expression: {
         Expr *ArgExpr = Arg.getAsExpr();
         if (ArgExpr && isa<DeclRefExpr>(ArgExpr) &&
             isa<TemplateDecl>(cast<DeclRefExpr>(ArgExpr)->getDecl())) {
           if (CheckTemplateArgument(TempParm, cast<DeclRefExpr>(ArgExpr)))
             Invalid = true;
-          
+
           // Add the converted template argument.
-          Decl *D 
+          Decl *D
             = cast<DeclRefExpr>(ArgExpr)->getDecl()->getCanonicalDecl();
           Converted.Append(TemplateArgument(Arg.getLocation(), D));
           continue;
         }
       }
         // fall through
-        
+
       case TemplateArgument::Type: {
         // We have a template template parameter but the template
         // argument does not refer to a template.
@@ -1573,11 +1572,11 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template,
         // it to the list of converted arguments.
         Converted.Append(Arg);
         break;
-        
+
       case TemplateArgument::Integral:
         assert(false && "Integral argument with template template parameter");
         break;
-      
+
       case TemplateArgument::Pack:
         assert(0 && "FIXME: Implement!");
         break;
@@ -1593,7 +1592,7 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template,
 ///
 /// This routine implements the semantics of C++ [temp.arg.type]. It
 /// returns true if an error occurred, and false otherwise.
-bool Sema::CheckTemplateArgument(TemplateTypeParmDecl *Param, 
+bool Sema::CheckTemplateArgument(TemplateTypeParmDecl *Param,
                                  QualType Arg, SourceLocation ArgLoc) {
   // C++ [temp.arg.type]p2:
   //   A local type, a type with no linkage, an unnamed type or a type
@@ -1609,7 +1608,7 @@ bool Sema::CheckTemplateArgument(TemplateTypeParmDecl *Param,
   if (Tag && Tag->getDecl()->getDeclContext()->isFunctionOrMethod())
     return Diag(ArgLoc, diag::err_template_arg_local_type)
       << QualType(Tag, 0);
-  else if (Tag && !Tag->getDecl()->getDeclName() && 
+  else if (Tag && !Tag->getDecl()->getDeclName() &&
            !Tag->getDecl()->getTypedefForAnonDecl()) {
     Diag(ArgLoc, diag::err_template_arg_unnamed_type);
     Diag(Tag->getDecl()->getLocation(), diag::note_template_unnamed_type_here);
@@ -1634,7 +1633,7 @@ bool Sema::CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg,
     return false;
 
   // C++ [temp.arg.nontype]p1:
-  // 
+  //
   //   A template-argument for a non-type, non-template
   //   template-parameter shall be one of: [...]
   //
@@ -1645,11 +1644,11 @@ bool Sema::CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg,
   //        the name refers to a function or array, or if the
   //        corresponding template-parameter is a reference; or
   DeclRefExpr *DRE = 0;
-  
+
   // Ignore (and complain about) any excess parentheses.
   while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {
     if (!Invalid) {
-      Diag(Arg->getSourceRange().getBegin(), 
+      Diag(Arg->getSourceRange().getBegin(),
            diag::err_template_arg_extra_parens)
         << Arg->getSourceRange();
       Invalid = true;
@@ -1665,7 +1664,7 @@ bool Sema::CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg,
     DRE = dyn_cast<DeclRefExpr>(Arg);
 
   if (!DRE || !isa<ValueDecl>(DRE->getDecl()))
-    return Diag(Arg->getSourceRange().getBegin(), 
+    return Diag(Arg->getSourceRange().getBegin(),
                 diag::err_template_arg_not_object_or_func_form)
       << Arg->getSourceRange();
 
@@ -1677,14 +1676,14 @@ bool Sema::CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg,
   // Cannot refer to non-static member functions
   if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(DRE->getDecl()))
     if (!Method->isStatic())
-      return Diag(Arg->getSourceRange().getBegin(), 
+      return Diag(Arg->getSourceRange().getBegin(),
                   diag::err_template_arg_method)
         << Method << Arg->getSourceRange();
-   
+
   // Functions must have external linkage.
   if (FunctionDecl *Func = dyn_cast<FunctionDecl>(DRE->getDecl())) {
     if (Func->getStorageClass() == FunctionDecl::Static) {
-      Diag(Arg->getSourceRange().getBegin(), 
+      Diag(Arg->getSourceRange().getBegin(),
            diag::err_template_arg_function_not_extern)
         << Func << Arg->getSourceRange();
       Diag(Func->getLocation(), diag::note_template_arg_internal_object)
@@ -1699,7 +1698,7 @@ bool Sema::CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg,
 
   if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
     if (!Var->hasGlobalStorage()) {
-      Diag(Arg->getSourceRange().getBegin(), 
+      Diag(Arg->getSourceRange().getBegin(),
            diag::err_template_arg_object_not_extern)
         << Var << Arg->getSourceRange();
       Diag(Var->getLocation(), diag::note_template_arg_internal_object)
@@ -1711,19 +1710,19 @@ bool Sema::CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg,
     Entity = Var;
     return Invalid;
   }
-  
+
   // We found something else, but we don't know specifically what it is.
-  Diag(Arg->getSourceRange().getBegin(), 
+  Diag(Arg->getSourceRange().getBegin(),
        diag::err_template_arg_not_object_or_func)
       << Arg->getSourceRange();
-  Diag(DRE->getDecl()->getLocation(), 
+  Diag(DRE->getDecl()->getLocation(),
        diag::note_template_arg_refers_here);
   return true;
 }
 
 /// \brief Checks whether the given template argument is a pointer to
 /// member constant according to C++ [temp.arg.nontype]p1.
-bool 
+bool
 Sema::CheckTemplateArgumentPointerToMember(Expr *Arg, NamedDecl *&Member) {
   bool Invalid = false;
 
@@ -1736,7 +1735,7 @@ Sema::CheckTemplateArgumentPointerToMember(Expr *Arg, NamedDecl *&Member) {
     return false;
 
   // C++ [temp.arg.nontype]p1:
-  // 
+  //
   //   A template-argument for a non-type, non-template
   //   template-parameter shall be one of: [...]
   //
@@ -1746,7 +1745,7 @@ Sema::CheckTemplateArgumentPointerToMember(Expr *Arg, NamedDecl *&Member) {
   // Ignore (and complain about) any excess parentheses.
   while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {
     if (!Invalid) {
-      Diag(Arg->getSourceRange().getBegin(), 
+      Diag(Arg->getSourceRange().getBegin(),
            diag::err_template_arg_extra_parens)
         << Arg->getSourceRange();
       Invalid = true;
@@ -1776,10 +1775,10 @@ Sema::CheckTemplateArgumentPointerToMember(Expr *Arg, NamedDecl *&Member) {
   }
 
   // We found something else, but we don't know specifically what it is.
-  Diag(Arg->getSourceRange().getBegin(), 
+  Diag(Arg->getSourceRange().getBegin(),
        diag::err_template_arg_not_pointer_to_member_form)
       << Arg->getSourceRange();
-  Diag(DRE->getDecl()->getLocation(), 
+  Diag(DRE->getDecl()->getLocation(),
        diag::note_template_arg_refers_here);
   return true;
 }
@@ -1794,7 +1793,7 @@ Sema::CheckTemplateArgumentPointerToMember(Expr *Arg, NamedDecl *&Member) {
 ///
 /// If no error was detected, Converted receives the converted template argument.
 bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
-                                 QualType InstantiatedParamType, Expr *&Arg, 
+                                 QualType InstantiatedParamType, Expr *&Arg,
                                  TemplateArgument &Converted) {
   SourceLocation StartLoc = Arg->getSourceRange().getBegin();
 
@@ -1830,7 +1829,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
     SourceLocation NonConstantLoc;
     llvm::APSInt Value;
     if (!ArgType->isIntegralType() && !ArgType->isEnumeralType()) {
-      Diag(Arg->getSourceRange().getBegin(), 
+      Diag(Arg->getSourceRange().getBegin(),
            diag::err_template_arg_not_integral_or_enumeral)
         << ArgType << Arg->getSourceRange();
       Diag(Param->getLocation(), diag::note_template_param_here);
@@ -1859,7 +1858,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
       ImpCastExprToType(Arg, ParamType);
     } else {
       // We can't perform this conversion.
-      Diag(Arg->getSourceRange().getBegin(), 
+      Diag(Arg->getSourceRange().getBegin(),
            diag::err_template_arg_not_convertible)
         << Arg->getType() << InstantiatedParamType << Arg->getSourceRange();
       Diag(Param->getLocation(), diag::note_template_param_here);
@@ -1885,7 +1884,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
       // Check that we don't overflow the template parameter type.
       unsigned AllowedBits = Context.getTypeSize(IntegerType);
       if (Value.getActiveBits() > AllowedBits) {
-        Diag(Arg->getSourceRange().getBegin(), 
+        Diag(Arg->getSourceRange().getBegin(),
              diag::err_template_arg_too_large)
           << Value.toString(10) << Param->getType()
           << Arg->getSourceRange();
@@ -1909,7 +1908,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
     }
 
     Converted = TemplateArgument(StartLoc, Value,
-                                 ParamType->isEnumeralType() ? ParamType 
+                                 ParamType->isEnumeralType() ? ParamType
                                                              : IntegerType);
     return false;
   }
@@ -1939,7 +1938,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
       (ParamType->isMemberPointerType() &&
        ParamType->getAs<MemberPointerType>()->getPointeeType()
          ->isFunctionType())) {
-    if (Context.hasSameUnqualifiedType(ArgType, 
+    if (Context.hasSameUnqualifiedType(ArgType,
                                        ParamType.getNonReferenceType())) {
       // We don't have to do anything: the types already match.
     } else if (ArgType->isNullPtrType() && (ParamType->isPointerType() ||
@@ -1949,7 +1948,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
     } else if (ArgType->isFunctionType() && ParamType->isPointerType()) {
       ArgType = Context.getPointerType(ArgType);
       ImpCastExprToType(Arg, ArgType);
-    } else if (FunctionDecl *Fn 
+    } else if (FunctionDecl *Fn
                  = ResolveAddressOfOverloadedFunction(Arg, ParamType, true)) {
       if (DiagnoseUseOfDecl(Fn, Arg->getSourceRange().getBegin()))
         return true;
@@ -1962,16 +1961,16 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
       }
     }
 
-    if (!Context.hasSameUnqualifiedType(ArgType, 
+    if (!Context.hasSameUnqualifiedType(ArgType,
                                         ParamType.getNonReferenceType())) {
       // We can't perform this conversion.
-      Diag(Arg->getSourceRange().getBegin(), 
+      Diag(Arg->getSourceRange().getBegin(),
            diag::err_template_arg_not_convertible)
         << Arg->getType() << InstantiatedParamType << Arg->getSourceRange();
       Diag(Param->getLocation(), diag::note_template_param_here);
       return true;
     }
-    
+
     if (ParamType->isMemberPointerType()) {
       NamedDecl *Member = 0;
       if (CheckTemplateArgumentPointerToMember(Arg, Member))
@@ -1982,7 +1981,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
       Converted = TemplateArgument(StartLoc, Member);
       return false;
     }
-    
+
     NamedDecl *Entity = 0;
     if (CheckTemplateArgumentAddressOfObjectOrFunction(Arg, Entity))
       return true;
@@ -2013,16 +2012,16 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
       ArgType = ParamType;
       ImpCastExprToType(Arg, ParamType);
     }
-    
+
     if (!Context.hasSameUnqualifiedType(ArgType, ParamType)) {
       // We can't perform this conversion.
-      Diag(Arg->getSourceRange().getBegin(), 
+      Diag(Arg->getSourceRange().getBegin(),
            diag::err_template_arg_not_convertible)
         << Arg->getType() << InstantiatedParamType << Arg->getSourceRange();
       Diag(Param->getLocation(), diag::note_template_param_here);
       return true;
     }
-    
+
     NamedDecl *Entity = 0;
     if (CheckTemplateArgumentAddressOfObjectOrFunction(Arg, Entity))
       return true;
@@ -2032,7 +2031,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
     Converted = TemplateArgument(StartLoc, Entity);
     return false;
   }
-    
+
   if (const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>()) {
     //   -- For a non-type template-parameter of type reference to
     //      object, no conversions apply. The type referred to by the
@@ -2044,7 +2043,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
            "Only object references allowed here");
 
     if (!Context.hasSameUnqualifiedType(ParamRefType->getPointeeType(), ArgType)) {
-      Diag(Arg->getSourceRange().getBegin(), 
+      Diag(Arg->getSourceRange().getBegin(),
            diag::err_template_arg_no_ref_bind)
         << InstantiatedParamType << Arg->getType()
         << Arg->getSourceRange();
@@ -2052,10 +2051,10 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
       return true;
     }
 
-    unsigned ParamQuals 
+    unsigned ParamQuals
       = Context.getCanonicalType(ParamType).getCVRQualifiers();
     unsigned ArgQuals = Context.getCanonicalType(ArgType).getCVRQualifiers();
-    
+
     if ((ParamQuals | ArgQuals) != ParamQuals) {
       Diag(Arg->getSourceRange().getBegin(),
            diag::err_template_arg_ref_bind_ignores_quals)
@@ -2064,7 +2063,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
       Diag(Param->getLocation(), diag::note_template_param_here);
       return true;
     }
-    
+
     NamedDecl *Entity = 0;
     if (CheckTemplateArgumentAddressOfObjectOrFunction(Arg, Entity))
       return true;
@@ -2087,17 +2086,17 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
     ImpCastExprToType(Arg, ParamType);
   } else {
     // We can't perform this conversion.
-    Diag(Arg->getSourceRange().getBegin(), 
+    Diag(Arg->getSourceRange().getBegin(),
          diag::err_template_arg_not_convertible)
       << Arg->getType() << InstantiatedParamType << Arg->getSourceRange();
     Diag(Param->getLocation(), diag::note_template_param_here);
-    return true;    
+    return true;
   }
 
   NamedDecl *Member = 0;
   if (CheckTemplateArgumentPointerToMember(Arg, Member))
     return true;
-  
+
   if (Member)
     Member = cast<NamedDecl>(Member->getCanonicalDecl());
   Converted = TemplateArgument(StartLoc, Member);
@@ -2125,9 +2124,9 @@ bool Sema::CheckTemplateArgument(TemplateTemplateParmDecl *Param,
   // Note that we also allow template template parameters here, which
   // will happen when we are dealing with, e.g., class template
   // partial specializations.
-  if (!isa<ClassTemplateDecl>(Template) && 
+  if (!isa<ClassTemplateDecl>(Template) &&
       !isa<TemplateTemplateParmDecl>(Template)) {
-    assert(isa<FunctionTemplateDecl>(Template) && 
+    assert(isa<FunctionTemplateDecl>(Template) &&
            "Only function templates are possible here");
     Diag(Arg->getLocStart(), diag::err_template_arg_not_class_template);
     Diag(Template->getLocation(), diag::note_template_arg_refers_here_func)
@@ -2143,7 +2142,7 @@ bool Sema::CheckTemplateArgument(TemplateTemplateParmDecl *Param,
 /// \brief Determine whether the given template parameter lists are
 /// equivalent.
 ///
-/// \param New  The new template parameter list, typically written in the 
+/// \param New  The new template parameter list, typically written in the
 /// source code as part of a new template declaration.
 ///
 /// \param Old  The old template parameter list, typically found via
@@ -2165,7 +2164,7 @@ bool Sema::CheckTemplateArgument(TemplateTemplateParmDecl *Param,
 ///
 /// \returns True if the template parameter lists are equal, false
 /// otherwise.
-bool 
+bool
 Sema::TemplateParameterListsAreEqual(TemplateParameterList *New,
                                      TemplateParameterList *Old,
                                      bool Complain,
@@ -2177,7 +2176,7 @@ Sema::TemplateParameterListsAreEqual(TemplateParameterList *New,
       if (TemplateArgLoc.isValid()) {
         Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
         NextDiag = diag::note_template_param_list_different_arity;
-      } 
+      }
       Diag(New->getTemplateLoc(), NextDiag)
           << (New->size() > Old->size())
           << IsTemplateTemplateParm
@@ -2218,15 +2217,15 @@ Sema::TemplateParameterListsAreEqual(TemplateParameterList *New,
       // types within the template parameter list of the template template
       // parameter can be checked, and (2) the template type parameter depths
       // will match up.
-      QualType OldParmType 
+      QualType OldParmType
         = Context.getTypeDeclType(cast<TemplateTypeParmDecl>(*OldParm));
-      QualType NewParmType 
+      QualType NewParmType
         = Context.getTypeDeclType(cast<TemplateTypeParmDecl>(*NewParm));
-      assert(Context.getCanonicalType(OldParmType) == 
-             Context.getCanonicalType(NewParmType) && 
+      assert(Context.getCanonicalType(OldParmType) ==
+             Context.getCanonicalType(NewParmType) &&
              "type parameter mismatch?");
 #endif
-    } else if (NonTypeTemplateParmDecl *OldNTTP 
+    } else if (NonTypeTemplateParmDecl *OldNTTP
                  = dyn_cast<NonTypeTemplateParmDecl>(*OldParm)) {
       // The types of non-type template parameters must agree.
       NonTypeTemplateParmDecl *NewNTTP
@@ -2236,14 +2235,14 @@ Sema::TemplateParameterListsAreEqual(TemplateParameterList *New,
         if (Complain) {
           unsigned NextDiag = diag::err_template_nontype_parm_different_type;
           if (TemplateArgLoc.isValid()) {
-            Diag(TemplateArgLoc, 
+            Diag(TemplateArgLoc,
                  diag::err_template_arg_template_params_mismatch);
             NextDiag = diag::note_template_nontype_parm_different_type;
           }
           Diag(NewNTTP->getLocation(), NextDiag)
             << NewNTTP->getType()
             << IsTemplateTemplateParm;
-          Diag(OldNTTP->getLocation(), 
+          Diag(OldNTTP->getLocation(),
                diag::note_template_nontype_parm_prev_declaration)
             << OldNTTP->getType();
         }
@@ -2253,9 +2252,9 @@ Sema::TemplateParameterListsAreEqual(TemplateParameterList *New,
       // The template parameter lists of template template
       // parameters must agree.
       // FIXME: Could we perform a faster "type" comparison here?
-      assert(isa<TemplateTemplateParmDecl>(*OldParm) && 
+      assert(isa<TemplateTemplateParmDecl>(*OldParm) &&
              "Only template template parameters handled here");
-      TemplateTemplateParmDecl *OldTTP 
+      TemplateTemplateParmDecl *OldTTP
         = cast<TemplateTemplateParmDecl>(*OldParm);
       TemplateTemplateParmDecl *NewTTP
         = cast<TemplateTemplateParmDecl>(*NewParm);
@@ -2275,29 +2274,29 @@ Sema::TemplateParameterListsAreEqual(TemplateParameterList *New,
 ///
 /// If the template declaration is valid in this scope, returns
 /// false. Otherwise, issues a diagnostic and returns true.
-bool 
+bool
 Sema::CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams) {
   // Find the nearest enclosing declaration scope.
   while ((S->getFlags() & Scope::DeclScope) == 0 ||
          (S->getFlags() & Scope::TemplateParamScope) != 0)
     S = S->getParent();
-  
+
   // C++ [temp]p2:
   //   A template-declaration can appear only as a namespace scope or
   //   class scope declaration.
   DeclContext *Ctx = static_cast<DeclContext *>(S->getEntity());
   if (Ctx && isa<LinkageSpecDecl>(Ctx) &&
       cast<LinkageSpecDecl>(Ctx)->getLanguage() != LinkageSpecDecl::lang_cxx)
-    return Diag(TemplateParams->getTemplateLoc(), diag::err_template_linkage) 
+    return Diag(TemplateParams->getTemplateLoc(), diag::err_template_linkage)
              << TemplateParams->getSourceRange();
-  
+
   while (Ctx && isa<LinkageSpecDecl>(Ctx))
     Ctx = Ctx->getParent();
 
   if (Ctx && (Ctx->isFileContext() || Ctx->isRecord()))
     return false;
 
-  return Diag(TemplateParams->getTemplateLoc(), 
+  return Diag(TemplateParams->getTemplateLoc(),
               diag::err_template_outside_namespace_or_class_scope)
     << TemplateParams->getSourceRange();
 }
@@ -2306,11 +2305,11 @@ Sema::CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams) {
 /// instantiation in the current context is well-formed.
 ///
 /// This routine determines whether a class template specialization or
-/// explicit instantiation can be declared in the current context 
-/// (C++ [temp.expl.spec]p2, C++0x [temp.explicit]p2) and emits 
-/// appropriate diagnostics if there was an error. It returns true if 
+/// explicit instantiation can be declared in the current context
+/// (C++ [temp.expl.spec]p2, C++0x [temp.explicit]p2) and emits
+/// appropriate diagnostics if there was an error. It returns true if
 // there was an error that we cannot recover from, and false otherwise.
-bool 
+bool
 Sema::CheckClassTemplateSpecializationScope(ClassTemplateDecl *ClassTemplate,
                                    ClassTemplateSpecializationDecl *PrevDecl,
                                             SourceLocation TemplateNameLoc,
@@ -2338,7 +2337,7 @@ Sema::CheckClassTemplateSpecializationScope(ClassTemplateDecl *ClassTemplate,
   }
 
   DeclContext *DC = CurContext->getEnclosingNamespaceContext();
-  DeclContext *TemplateContext 
+  DeclContext *TemplateContext
     = ClassTemplate->getDeclContext()->getEnclosingNamespaceContext();
   if ((!PrevDecl || PrevDecl->getSpecializationKind() == TSK_Undeclared) &&
       !ExplicitInstantiation) {
@@ -2352,7 +2351,7 @@ Sema::CheckClassTemplateSpecializationScope(ClassTemplateDecl *ClassTemplate,
           << ClassTemplate << ScopeSpecifierRange;
       else if (isa<NamespaceDecl>(TemplateContext))
         Diag(TemplateNameLoc, diag::err_template_spec_decl_out_of_scope)
-          << PartialSpecialization << ClassTemplate 
+          << PartialSpecialization << ClassTemplate
           << cast<NamedDecl>(TemplateContext) << ScopeSpecifierRange;
 
       Diag(ClassTemplate->getLocation(), diag::note_template_decl_here);
@@ -2379,10 +2378,10 @@ Sema::CheckClassTemplateSpecializationScope(ClassTemplateDecl *ClassTemplate,
         Diag(TemplateNameLoc, diag::err_template_spec_redecl_out_of_scope)
           << Kind << ClassTemplate
           << cast<NamedDecl>(TemplateContext) << ScopeSpecifierRange;
-      else 
+      else
         SuppressedDiag = true;
     }
-    
+
     if (!SuppressedDiag)
       Diag(ClassTemplate->getLocation(), diag::note_template_decl_here);
   }
@@ -2413,16 +2412,16 @@ bool Sema::CheckClassTemplatePartialSpecializationArgs(
   // FIXME: the interface to this function will have to change to
   // accommodate variadic templates.
   MirrorsPrimaryTemplate = true;
-  
+
   const TemplateArgument *ArgList = TemplateArgs.getFlatArguments();
-  
+
   for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
     // Determine whether the template argument list of the partial
     // specialization is identical to the implicit argument list of
     // the primary template. The caller may need to diagnostic this as
     // an error per C++ [temp.class.spec]p9b3.
     if (MirrorsPrimaryTemplate) {
-      if (TemplateTypeParmDecl *TTP 
+      if (TemplateTypeParmDecl *TTP
             = dyn_cast<TemplateTypeParmDecl>(TemplateParams->getParam(I))) {
         if (Context.getCanonicalType(Context.getTypeDeclType(TTP)) !=
               Context.getCanonicalType(ArgList[I].getAsType()))
@@ -2432,11 +2431,11 @@ bool Sema::CheckClassTemplatePartialSpecializationArgs(
                                                  TemplateParams->getParam(I))) {
         // FIXME: We should settle on either Declaration storage or
         // Expression storage for template template parameters.
-        TemplateTemplateParmDecl *ArgDecl 
+        TemplateTemplateParmDecl *ArgDecl
           = dyn_cast_or_null<TemplateTemplateParmDecl>(
                                                   ArgList[I].getAsDecl());
         if (!ArgDecl)
-          if (DeclRefExpr *DRE 
+          if (DeclRefExpr *DRE
                 = dyn_cast_or_null<DeclRefExpr>(ArgList[I].getAsExpr()))
             ArgDecl = dyn_cast<TemplateTemplateParmDecl>(DRE->getDecl());
 
@@ -2447,7 +2446,7 @@ bool Sema::CheckClassTemplatePartialSpecializationArgs(
       }
     }
 
-    NonTypeTemplateParmDecl *Param 
+    NonTypeTemplateParmDecl *Param
       = dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(I));
     if (!Param) {
       continue;
@@ -2468,9 +2467,9 @@ bool Sema::CheckClassTemplatePartialSpecializationArgs(
     // specialized non-type arguments, so skip any non-specialized
     // arguments.
     if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ArgExpr))
-      if (NonTypeTemplateParmDecl *NTTP 
+      if (NonTypeTemplateParmDecl *NTTP
             = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl())) {
-        if (MirrorsPrimaryTemplate && 
+        if (MirrorsPrimaryTemplate &&
             (Param->getIndex() != NTTP->getIndex() ||
              Param->getDepth() != NTTP->getDepth()))
           MirrorsPrimaryTemplate = false;
@@ -2486,7 +2485,7 @@ bool Sema::CheckClassTemplatePartialSpecializationArgs(
     //        specialization except when the argument expression is a
     //        simple identifier.
     if (ArgExpr->isTypeDependent() || ArgExpr->isValueDependent()) {
-      Diag(ArgExpr->getLocStart(), 
+      Diag(ArgExpr->getLocStart(),
            diag::err_dependent_non_type_arg_in_partial_spec)
         << ArgExpr->getSourceRange();
       return true;
@@ -2496,7 +2495,7 @@ bool Sema::CheckClassTemplatePartialSpecializationArgs(
     //        specialized non-type argument shall not be dependent on a
     //        parameter of the specialization.
     if (Param->getType()->isDependentType()) {
-      Diag(ArgExpr->getLocStart(), 
+      Diag(ArgExpr->getLocStart(),
            diag::err_dependent_typed_non_type_arg_in_partial_spec)
         << Param->getType()
         << ArgExpr->getSourceRange();
@@ -2513,7 +2512,7 @@ bool Sema::CheckClassTemplatePartialSpecializationArgs(
 Sema::DeclResult
 Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
                                        TagUseKind TUK,
-                                       SourceLocation KWLoc, 
+                                       SourceLocation KWLoc,
                                        const CXXScopeSpec &SS,
                                        TemplateTy TemplateD,
                                        SourceLocation TemplateNameLoc,
@@ -2527,7 +2526,7 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
 
   // Find the class template we're specializing
   TemplateName Name = TemplateD.getAsVal<TemplateName>();
-  ClassTemplateDecl *ClassTemplate 
+  ClassTemplateDecl *ClassTemplate
     = cast<ClassTemplateDecl>(Name.getAsTemplateDecl());
 
   bool isPartialSpecialization = false;
@@ -2535,8 +2534,8 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
   // Check the validity of the template headers that introduce this
   // template.
   TemplateParameterList *TemplateParams
-    = MatchTemplateParametersToScopeSpecifier(TemplateNameLoc, SS, 
-                        (TemplateParameterList**)TemplateParameterLists.get(), 
+    = MatchTemplateParametersToScopeSpecifier(TemplateNameLoc, SS,
+                        (TemplateParameterList**)TemplateParameterLists.get(),
                                               TemplateParameterLists.size());
   if (TemplateParams && TemplateParams->size() > 0) {
     isPartialSpecialization = true;
@@ -2548,14 +2547,14 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
       Decl *Param = TemplateParams->getParam(I);
       if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
         if (TTP->hasDefaultArgument()) {
-          Diag(TTP->getDefaultArgumentLoc(), 
+          Diag(TTP->getDefaultArgumentLoc(),
                diag::err_default_arg_in_partial_spec);
           TTP->setDefaultArgument(QualType(), SourceLocation(), false);
         }
       } else if (NonTypeTemplateParmDecl *NTTP
                    = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
         if (Expr *DefArg = NTTP->getDefaultArgument()) {
-          Diag(NTTP->getDefaultArgumentLoc(), 
+          Diag(NTTP->getDefaultArgumentLoc(),
                diag::err_default_arg_in_partial_spec)
             << DefArg->getSourceRange();
           NTTP->setDefaultArgument(0);
@@ -2564,7 +2563,7 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
       } else {
         TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(Param);
         if (Expr *DefArg = TTP->getDefaultArgument()) {
-          Diag(TTP->getDefaultArgumentLoc(), 
+          Diag(TTP->getDefaultArgumentLoc(),
                diag::err_default_arg_in_partial_spec)
             << DefArg->getSourceRange();
           TTP->setDefaultArgument(0);
@@ -2586,13 +2585,13 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
   case DeclSpec::TST_class:  Kind = TagDecl::TK_class; break;
   }
   if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(),
-                                    Kind, KWLoc, 
+                                    Kind, KWLoc,
                                     *ClassTemplate->getIdentifier())) {
-    Diag(KWLoc, diag::err_use_with_wrong_tag) 
+    Diag(KWLoc, diag::err_use_with_wrong_tag)
       << ClassTemplate
-      << CodeModificationHint::CreateReplacement(KWLoc, 
+      << CodeModificationHint::CreateReplacement(KWLoc,
                             ClassTemplate->getTemplatedDecl()->getKindName());
-    Diag(ClassTemplate->getTemplatedDecl()->getLocation(), 
+    Diag(ClassTemplate->getTemplatedDecl()->getLocation(),
          diag::note_previous_use);
     Kind = ClassTemplate->getTemplatedDecl()->getTagKind();
   }
@@ -2605,15 +2604,15 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
   // template.
   TemplateArgumentListBuilder Converted(ClassTemplate->getTemplateParameters(),
                                         TemplateArgs.size());
-  if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc, LAngleLoc, 
+  if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc, LAngleLoc,
                                 TemplateArgs.data(), TemplateArgs.size(),
                                 RAngleLoc, false, Converted))
     return true;
 
-  assert((Converted.structuredSize() == 
+  assert((Converted.structuredSize() ==
             ClassTemplate->getTemplateParameters()->size()) &&
          "Converted template argument list is too short!");
-  
+
   // Find the class template (partial) specialization declaration that
   // corresponds to these arguments.
   llvm::FoldingSetNodeID ID;
@@ -2627,11 +2626,11 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
     if (MirrorsPrimaryTemplate) {
       // C++ [temp.class.spec]p9b3:
       //
-      //   -- The argument list of the specialization shall not be identical 
-      //      to the implicit argument list of the primary template. 
+      //   -- The argument list of the specialization shall not be identical
+      //      to the implicit argument list of the primary template.
       Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
         << (TUK == TUK_Definition)
-        << CodeModificationHint::CreateRemoval(SourceRange(LAngleLoc, 
+        << CodeModificationHint::CreateRemoval(SourceRange(LAngleLoc,
                                                            RAngleLoc));
       return CheckClassTemplate(S, TagSpec, TUK, KWLoc, SS,
                                 ClassTemplate->getIdentifier(),
@@ -2642,7 +2641,7 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
     }
 
     // FIXME: Template parameter list matters, too
-    ClassTemplatePartialSpecializationDecl::Profile(ID, 
+    ClassTemplatePartialSpecializationDecl::Profile(ID,
                                                    Converted.getFlatArguments(),
                                                    Converted.flatSize(),
                                                     Context);
@@ -2656,7 +2655,7 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
 
   if (isPartialSpecialization)
     PrevDecl
-      = ClassTemplate->getPartialSpecializations().FindNodeOrInsertPos(ID, 
+      = ClassTemplate->getPartialSpecializations().FindNodeOrInsertPos(ID,
                                                                     InsertPos);
   else
     PrevDecl
@@ -2667,7 +2666,7 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
   // Check whether we can declare a class template specialization in
   // the current scope.
   if (CheckClassTemplateSpecializationScope(ClassTemplate, PrevDecl,
-                                            TemplateNameLoc, 
+                                            TemplateNameLoc,
                                             SS.getRange(),
                                             isPartialSpecialization,
                                             /*ExplicitInstantiation=*/false))
@@ -2693,12 +2692,12 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
                                                   Converted.flatSize());
 
     // Create a new class template partial specialization declaration node.
-    TemplateParameterList *TemplateParams 
+    TemplateParameterList *TemplateParams
       = static_cast<TemplateParameterList*>(*TemplateParameterLists.get());
     ClassTemplatePartialSpecializationDecl *PrevPartial
       = cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl);
-    ClassTemplatePartialSpecializationDecl *Partial 
-      = ClassTemplatePartialSpecializationDecl::Create(Context, 
+    ClassTemplatePartialSpecializationDecl *Partial
+      = ClassTemplatePartialSpecializationDecl::Create(Context,
                                              ClassTemplate->getDeclContext(),
                                                        TemplateNameLoc,
                                                        TemplateParams,
@@ -2734,11 +2733,11 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
         if (!DeducibleParams[I]) {
           NamedDecl *Param = cast<NamedDecl>(TemplateParams->getParam(I));
           if (Param->getDeclName())
-            Diag(Param->getLocation(), 
+            Diag(Param->getLocation(),
                  diag::note_partial_spec_unused_parameter)
               << Param->getDeclName();
           else
-            Diag(Param->getLocation(), 
+            Diag(Param->getLocation(),
                  diag::note_partial_spec_unused_parameter)
               << std::string("<anonymous>");
         }
@@ -2748,10 +2747,10 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
     // Create a new class template specialization declaration node for
     // this explicit specialization.
     Specialization
-      = ClassTemplateSpecializationDecl::Create(Context, 
+      = ClassTemplateSpecializationDecl::Create(Context,
                                              ClassTemplate->getDeclContext(),
                                                 TemplateNameLoc,
-                                                ClassTemplate, 
+                                                ClassTemplate,
                                                 Converted,
                                                 PrevDecl);
 
@@ -2759,7 +2758,7 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
       ClassTemplate->getSpecializations().RemoveNode(PrevDecl);
       ClassTemplate->getSpecializations().GetOrInsertNode(Specialization);
     } else {
-      ClassTemplate->getSpecializations().InsertNode(Specialization, 
+      ClassTemplate->getSpecializations().InsertNode(Specialization,
                                                      InsertPos);
     }
 
@@ -2775,7 +2774,7 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
       // FIXME: Should also handle explicit specialization after implicit
       // instantiation with a special diagnostic.
       SourceRange Range(TemplateNameLoc, RAngleLoc);
-      Diag(TemplateNameLoc, diag::err_redefinition) 
+      Diag(TemplateNameLoc, diag::err_redefinition)
         << Context.getTypeDeclType(Specialization) << Range;
       Diag(Def->getLocation(), diag::note_previous_definition);
       Specialization->setInvalidDecl();
@@ -2790,8 +2789,8 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
   // actually wrote the specialization, rather than formatting the
   // name based on the "canonical" representation used to store the
   // template arguments in the specialization.
-  QualType WrittenTy 
-    = Context.getTemplateSpecializationType(Name, 
+  QualType WrittenTy
+    = Context.getTemplateSpecializationType(Name,
                                             TemplateArgs.data(),
                                             TemplateArgs.size(),
                                             CanonType);
@@ -2807,7 +2806,7 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
   // but we also maintain the lexical context where the actual
   // definition occurs.
   Specialization->setLexicalDeclContext(CurContext);
-  
+
   // We may be starting the definition of this specialization.
   if (TUK == TUK_Definition)
     Specialization->startDefinition();
@@ -2819,34 +2818,34 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
   return DeclPtrTy::make(Specialization);
 }
 
-Sema::DeclPtrTy 
-Sema::ActOnTemplateDeclarator(Scope *S, 
+Sema::DeclPtrTy
+Sema::ActOnTemplateDeclarator(Scope *S,
                               MultiTemplateParamsArg TemplateParameterLists,
                               Declarator &D) {
   return HandleDeclarator(S, D, move(TemplateParameterLists), false);
 }
 
-Sema::DeclPtrTy 
-Sema::ActOnStartOfFunctionTemplateDef(Scope *FnBodyScope, 
+Sema::DeclPtrTy
+Sema::ActOnStartOfFunctionTemplateDef(Scope *FnBodyScope,
                                MultiTemplateParamsArg TemplateParameterLists,
                                       Declarator &D) {
   assert(getCurFunctionDecl() == 0 && "Function parsing confused");
   assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function &&
          "Not a function declarator!");
   DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
-  
+
   if (FTI.hasPrototype) {
-    // FIXME: Diagnose arguments without names in C. 
+    // FIXME: Diagnose arguments without names in C.
   }
-  
+
   Scope *ParentScope = FnBodyScope->getParent();
-  
-  DeclPtrTy DP = HandleDeclarator(ParentScope, D, 
+
+  DeclPtrTy DP = HandleDeclarator(ParentScope, D,
                                   move(TemplateParameterLists),
                                   /*IsFunctionDefinition=*/true);
-  if (FunctionTemplateDecl *FunctionTemplate 
+  if (FunctionTemplateDecl *FunctionTemplate
         = dyn_cast_or_null<FunctionTemplateDecl>(DP.getAs<Decl>()))
-    return ActOnStartOfFunctionDef(FnBodyScope, 
+    return ActOnStartOfFunctionDef(FnBodyScope,
                       DeclPtrTy::make(FunctionTemplate->getTemplatedDecl()));
   if (FunctionDecl *Function = dyn_cast_or_null<FunctionDecl>(DP.getAs<Decl>()))
     return ActOnStartOfFunctionDef(FnBodyScope, DeclPtrTy::make(Function));
@@ -2856,10 +2855,10 @@ Sema::ActOnStartOfFunctionTemplateDef(Scope *FnBodyScope,
 // Explicit instantiation of a class template specialization
 // FIXME: Implement extern template semantics
 Sema::DeclResult
-Sema::ActOnExplicitInstantiation(Scope *S, 
+Sema::ActOnExplicitInstantiation(Scope *S,
                                  SourceLocation ExternLoc,
                                  SourceLocation TemplateLoc,
-                                 unsigned TagSpec, 
+                                 unsigned TagSpec,
                                  SourceLocation KWLoc,
                                  const CXXScopeSpec &SS,
                                  TemplateTy TemplateD,
@@ -2871,7 +2870,7 @@ Sema::ActOnExplicitInstantiation(Scope *S,
                                  AttributeList *Attr) {
   // Find the class template we're specializing
   TemplateName Name = TemplateD.getAsVal<TemplateName>();
-  ClassTemplateDecl *ClassTemplate 
+  ClassTemplateDecl *ClassTemplate
     = cast<ClassTemplateDecl>(Name.getAsTemplateDecl());
 
   // Check that the specialization uses the same tag kind as the
@@ -2884,13 +2883,13 @@ Sema::ActOnExplicitInstantiation(Scope *S,
   case DeclSpec::TST_class:  Kind = TagDecl::TK_class; break;
   }
   if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(),
-                                    Kind, KWLoc, 
+                                    Kind, KWLoc,
                                     *ClassTemplate->getIdentifier())) {
-    Diag(KWLoc, diag::err_use_with_wrong_tag) 
+    Diag(KWLoc, diag::err_use_with_wrong_tag)
       << ClassTemplate
-      << CodeModificationHint::CreateReplacement(KWLoc, 
+      << CodeModificationHint::CreateReplacement(KWLoc,
                             ClassTemplate->getTemplatedDecl()->getKindName());
-    Diag(ClassTemplate->getTemplatedDecl()->getLocation(), 
+    Diag(ClassTemplate->getTemplatedDecl()->getLocation(),
          diag::note_previous_use);
     Kind = ClassTemplate->getTemplatedDecl()->getTagKind();
   }
@@ -2901,7 +2900,7 @@ Sema::ActOnExplicitInstantiation(Scope *S,
   //
   // This is C++ DR 275.
   if (CheckClassTemplateSpecializationScope(ClassTemplate, 0,
-                                            TemplateNameLoc, 
+                                            TemplateNameLoc,
                                             SS.getRange(),
                                             /*PartialSpecialization=*/false,
                                             /*ExplicitInstantiation=*/true))
@@ -2915,19 +2914,19 @@ Sema::ActOnExplicitInstantiation(Scope *S,
   // template.
   TemplateArgumentListBuilder Converted(ClassTemplate->getTemplateParameters(),
                                         TemplateArgs.size());
-  if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc, LAngleLoc, 
+  if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc, LAngleLoc,
                                 TemplateArgs.data(), TemplateArgs.size(),
                                 RAngleLoc, false, Converted))
     return true;
 
-  assert((Converted.structuredSize() == 
+  assert((Converted.structuredSize() ==
             ClassTemplate->getTemplateParameters()->size()) &&
          "Converted template argument list is too short!");
-  
+
   // Find the class template specialization declaration that
   // corresponds to these arguments.
   llvm::FoldingSetNodeID ID;
-  ClassTemplateSpecializationDecl::Profile(ID, 
+  ClassTemplateSpecializationDecl::Profile(ID,
                                            Converted.getFlatArguments(),
                                            Converted.flatSize(),
                                            Context);
@@ -2939,13 +2938,13 @@ Sema::ActOnExplicitInstantiation(Scope *S,
 
   bool SpecializationRequiresInstantiation = true;
   if (PrevDecl) {
-    if (PrevDecl->getSpecializationKind() 
+    if (PrevDecl->getSpecializationKind()
           == TSK_ExplicitInstantiationDefinition) {
       // This particular specialization has already been declared or
       // instantiated. We cannot explicitly instantiate it.
       Diag(TemplateNameLoc, diag::err_explicit_instantiation_duplicate)
         << Context.getTypeDeclType(PrevDecl);
-      Diag(PrevDecl->getLocation(), 
+      Diag(PrevDecl->getLocation(),
            diag::note_previous_explicit_instantiation);
       return DeclPtrTy::make(PrevDecl);
     }
@@ -2957,10 +2956,10 @@ Sema::ActOnExplicitInstantiation(Scope *S,
       //   an explicit specialization for that template, the explicit
       //   instantiation has no effect.
       if (!getLangOptions().CPlusPlus0x) {
-        Diag(TemplateNameLoc, 
+        Diag(TemplateNameLoc,
              diag::ext_explicit_instantiation_after_specialization)
           << Context.getTypeDeclType(PrevDecl);
-        Diag(PrevDecl->getLocation(), 
+        Diag(PrevDecl->getLocation(),
              diag::note_previous_template_specialization);
       }
 
@@ -2970,7 +2969,7 @@ Sema::ActOnExplicitInstantiation(Scope *S,
       // accurate reproduction of the source code; we don't actually
       // use it for anything, since it is semantically irrelevant.
       Specialization
-        = ClassTemplateSpecializationDecl::Create(Context, 
+        = ClassTemplateSpecializationDecl::Create(Context,
                                              ClassTemplate->getDeclContext(),
                                                   TemplateNameLoc,
                                                   ClassTemplate,
@@ -2996,13 +2995,13 @@ Sema::ActOnExplicitInstantiation(Scope *S,
     // Create a new class template specialization declaration node for
     // this explicit specialization.
     Specialization
-      = ClassTemplateSpecializationDecl::Create(Context, 
+      = ClassTemplateSpecializationDecl::Create(Context,
                                              ClassTemplate->getDeclContext(),
                                                 TemplateNameLoc,
                                                 ClassTemplate,
                                                 Converted, 0);
 
-    ClassTemplate->getSpecializations().InsertNode(Specialization, 
+    ClassTemplate->getSpecializations().InsertNode(Specialization,
                                                    InsertPos);
   }
 
@@ -3013,8 +3012,8 @@ Sema::ActOnExplicitInstantiation(Scope *S,
   // the explicit instantiation, rather than formatting the name based
   // on the "canonical" representation used to store the template
   // arguments in the specialization.
-  QualType WrittenTy 
-    = Context.getTemplateSpecializationType(Name, 
+  QualType WrittenTy
+    = Context.getTemplateSpecializationType(Name,
                                             TemplateArgs.data(),
                                             TemplateArgs.size(),
                                   Context.getTypeDeclType(Specialization));
@@ -3035,7 +3034,7 @@ Sema::ActOnExplicitInstantiation(Scope *S,
   // This check comes when we actually try to perform the
   // instantiation.
   TemplateSpecializationKind TSK
-    = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition 
+    = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition
                            : TSK_ExplicitInstantiationDeclaration;
   if (SpecializationRequiresInstantiation)
     InstantiateClassTemplateSpecialization(Specialization, TSK);
@@ -3048,10 +3047,10 @@ Sema::ActOnExplicitInstantiation(Scope *S,
 
 // Explicit instantiation of a member class of a class template.
 Sema::DeclResult
-Sema::ActOnExplicitInstantiation(Scope *S, 
+Sema::ActOnExplicitInstantiation(Scope *S,
                                  SourceLocation ExternLoc,
                                  SourceLocation TemplateLoc,
-                                 unsigned TagSpec, 
+                                 unsigned TagSpec,
                                  SourceLocation KWLoc,
                                  const CXXScopeSpec &SS,
                                  IdentifierInfo *Name,
@@ -3092,7 +3091,7 @@ Sema::ActOnExplicitInstantiation(Scope *S,
   if (getLangOptions().CPlusPlus0x) {
     // FIXME: In C++98, we would like to turn these errors into warnings,
     // dependent on a -Wc++0x flag.
-    DeclContext *PatternContext 
+    DeclContext *PatternContext
       = Pattern->getDeclContext()->getEnclosingNamespaceContext();
     if (!CurContext->Encloses(PatternContext)) {
       Diag(TemplateLoc, diag::err_explicit_instantiation_out_of_scope)
@@ -3102,19 +3101,19 @@ Sema::ActOnExplicitInstantiation(Scope *S,
   }
 
   TemplateSpecializationKind TSK
-    = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition 
+    = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition
                            : TSK_ExplicitInstantiationDeclaration;
-  
+
   if (!Record->getDefinition(Context)) {
     // If the class has a definition, instantiate it (and all of its
     // members, recursively).
     Pattern = cast_or_null<CXXRecordDecl>(Pattern->getDefinition(Context));
-    if (Pattern && InstantiateClass(TemplateLoc, Record, Pattern, 
+    if (Pattern && InstantiateClass(TemplateLoc, Record, Pattern,
                                     getTemplateInstantiationArgs(Record),
                                     TSK))
       return true;
   } else // Instantiate all of the members of the class.
-    InstantiateClassMembers(TemplateLoc, Record, 
+    InstantiateClassMembers(TemplateLoc, Record,
                             getTemplateInstantiationArgs(Record), TSK);
 
   // FIXME: We don't have any representation for explicit instantiations of
@@ -3127,7 +3126,7 @@ Sema::ActOnExplicitInstantiation(Scope *S,
 Sema::TypeResult
 Sema::ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS,
                         const IdentifierInfo &II, SourceLocation IdLoc) {
-  NestedNameSpecifier *NNS 
+  NestedNameSpecifier *NNS
     = static_cast<NestedNameSpecifier *>(SS.getScopeRep());
   if (!NNS)
     return true;
@@ -3142,9 +3141,9 @@ Sema::TypeResult
 Sema::ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS,
                         SourceLocation TemplateLoc, TypeTy *Ty) {
   QualType T = GetTypeFromParser(Ty);
-  NestedNameSpecifier *NNS 
+  NestedNameSpecifier *NNS
     = static_cast<NestedNameSpecifier *>(SS.getScopeRep());
-  const TemplateSpecializationType *TemplateId 
+  const TemplateSpecializationType *TemplateId
     = T->getAsTemplateSpecializationType();
   assert(TemplateId && "Expected a template specialization type");
 
@@ -3152,11 +3151,11 @@ Sema::ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS,
     // If we can compute a declaration context, then the "typename"
     // keyword was superfluous. Just build a QualifiedNameType to keep
     // track of the nested-name-specifier.
-    
+
     // FIXME: Note that the QualifiedNameType had the "typename" keyword!
     return Context.getQualifiedNameType(NNS, T).getAsOpaquePtr();
   }
-  
+
   return Context.getTypenameType(NNS, TemplateId).getAsOpaquePtr();
 }
 
@@ -3173,10 +3172,10 @@ Sema::CheckTypenameType(NestedNameSpecifier *NNS, const IdentifierInfo &II,
     // instantiation, then build a typename type.
     if (!CurrentInstantiation)
       return Context.getTypenameType(NNS, &II);
-    
+
     // The nested-name-specifier refers to the current instantiation, so the
     // "typename" keyword itself is superfluous. In C++03, the program is
-    // actually ill-formed. However, DR 382 (in C++0x CD1) allows such 
+    // actually ill-formed. However, DR 382 (in C++0x CD1) allows such
     // extraneous "typename" keywords, and we retroactively apply this DR to
     // C++03 code.
   }
@@ -3197,7 +3196,7 @@ Sema::CheckTypenameType(NestedNameSpecifier *NNS, const IdentifierInfo &II,
   assert(Ctx && "No declaration context?");
 
   DeclarationName Name(&II);
-  LookupResult Result = LookupQualifiedName(Ctx, Name, LookupOrdinaryName, 
+  LookupResult Result = LookupQualifiedName(Ctx, Name, LookupOrdinaryName,
                                             false);
   unsigned DiagID = 0;
   Decl *Referenced = 0;
@@ -3247,20 +3246,19 @@ Sema::CheckTypenameType(NestedNameSpecifier *NNS, const IdentifierInfo &II,
 
 namespace {
   // See Sema::RebuildTypeInCurrentInstantiation
-  class VISIBILITY_HIDDEN CurrentInstantiationRebuilder 
-    : public TreeTransform<CurrentInstantiationRebuilder> 
-  {
+  class VISIBILITY_HIDDEN CurrentInstantiationRebuilder
+    : public TreeTransform<CurrentInstantiationRebuilder> {
     SourceLocation Loc;
     DeclarationName Entity;
-    
+
   public:
-    CurrentInstantiationRebuilder(Sema &SemaRef, 
+    CurrentInstantiationRebuilder(Sema &SemaRef,
                                   SourceLocation Loc,
-                                  DeclarationName Entity) 
-    : TreeTransform<CurrentInstantiationRebuilder>(SemaRef), 
+                                  DeclarationName Entity)
+    : TreeTransform<CurrentInstantiationRebuilder>(SemaRef),
       Loc(Loc), Entity(Entity) { }
-    
-    /// \brief Determine whether the given type \p T has already been 
+
+    /// \brief Determine whether the given type \p T has already been
     /// transformed.
     ///
     /// For the purposes of type reconstruction, a type has already been
@@ -3268,14 +3266,14 @@ namespace {
     bool AlreadyTransformed(QualType T) {
       return T.isNull() || !T->isDependentType();
     }
-    
-    /// \brief Returns the location of the entity whose type is being 
+
+    /// \brief Returns the location of the entity whose type is being
     /// rebuilt.
     SourceLocation getBaseLocation() { return Loc; }
-    
+
     /// \brief Returns the name of the entity whose type is being rebuilt.
     DeclarationName getBaseEntity() { return Entity; }
-    
+
     /// \brief Transforms an expression by returning the expression itself
     /// (an identity function).
     ///
@@ -3284,7 +3282,7 @@ namespace {
     Sema::OwningExprResult TransformExpr(Expr *E) {
       return getSema().Owned(E);
     }
-    
+
     /// \brief Transforms a typename type by determining whether the type now
     /// refers to a member of the current instantiation, and then
     /// type-checking and building a QualifiedNameType (when possible).
@@ -3292,7 +3290,7 @@ namespace {
   };
 }
 
-QualType 
+QualType
 CurrentInstantiationRebuilder::TransformTypenameType(const TypenameType *T) {
   NestedNameSpecifier *NNS
     = TransformNestedNameSpecifier(T->getQualifier(),
@@ -3308,30 +3306,30 @@ CurrentInstantiationRebuilder::TransformTypenameType(const TypenameType *T) {
   SS.setScopeRep(NNS);
   if (NNS == T->getQualifier() && getSema().computeDeclContext(SS) == 0)
     return QualType(T, 0);
-  
-  // Rebuild the typename type, which will probably turn into a 
+
+  // Rebuild the typename type, which will probably turn into a
   // QualifiedNameType.
   if (const TemplateSpecializationType *TemplateId = T->getTemplateId()) {
-    QualType NewTemplateId 
+    QualType NewTemplateId
       = TransformType(QualType(TemplateId, 0));
     if (NewTemplateId.isNull())
       return QualType();
-    
+
     if (NNS == T->getQualifier() &&
         NewTemplateId == QualType(TemplateId, 0))
       return QualType(T, 0);
-    
+
     return getDerived().RebuildTypenameType(NNS, NewTemplateId);
   }
-  
+
   return getDerived().RebuildTypenameType(NNS, T->getIdentifier());
 }
 
 /// \brief Rebuilds a type within the context of the current instantiation.
 ///
-/// The type \p T is part of the type of an out-of-line member definition of 
+/// The type \p T is part of the type of an out-of-line member definition of
 /// a class template (or class template partial specialization) that was parsed
-/// and constructed before we entered the scope of the class template (or 
+/// and constructed before we entered the scope of the class template (or
 /// partial specialization thereof). This routine will rebuild that type now
 /// that we have entered the declarator's scope, which may produce different
 /// canonical types, e.g.,
@@ -3357,7 +3355,7 @@ QualType Sema::RebuildTypeInCurrentInstantiation(QualType T, SourceLocation Loc,
                                                  DeclarationName Name) {
   if (T.isNull() || !T->isDependentType())
     return T;
-  
+
   CurrentInstantiationRebuilder Rebuilder(*this, Loc, Name);
   return Rebuilder.TransformType(T);
 }