Update clang to 97654.

1 files changed, 48 insertions, 10 deletions

diff --git a/lib/Sema/SemaTemplate.cpp b/lib/Sema/SemaTemplate.cpp
index 10e411f..0321958 100644
--- a/lib/Sema/SemaTemplate.cpp
+++ b/lib/Sema/SemaTemplate.cpp
@@ -3242,6 +3242,23 @@ bool Sema::CheckClassTemplatePartialSpecializationArgs(
   return false;
 }
 
+/// \brief Retrieve the previous declaration of the given declaration.
+static NamedDecl *getPreviousDecl(NamedDecl *ND) {
+  if (VarDecl *VD = dyn_cast<VarDecl>(ND))
+    return VD->getPreviousDeclaration();
+  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
+    return FD->getPreviousDeclaration();
+  if (TagDecl *TD = dyn_cast<TagDecl>(ND))
+    return TD->getPreviousDeclaration();
+  if (TypedefDecl *TD = dyn_cast<TypedefDecl>(ND))
+    return TD->getPreviousDeclaration();
+  if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(ND))
+    return FTD->getPreviousDeclaration();
+  if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(ND))
+    return CTD->getPreviousDeclaration();
+  return 0;
+}
+
 Sema::DeclResult
 Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
                                        TagUseKind TUK,
@@ -3547,15 +3564,26 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
   //   instantiation to take place, in every translation unit in which such a 
   //   use occurs; no diagnostic is required.
   if (PrevDecl && PrevDecl->getPointOfInstantiation().isValid()) {
-    SourceRange Range(TemplateNameLoc, RAngleLoc);
-    Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
-      << Context.getTypeDeclType(Specialization) << Range;
+    bool Okay = false;
+    for (NamedDecl *Prev = PrevDecl; Prev; Prev = getPreviousDecl(Prev)) {
+      // Is there any previous explicit specialization declaration?
+      if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization) {
+        Okay = true;
+        break;
+      }
+    }
 
-    Diag(PrevDecl->getPointOfInstantiation(), 
-         diag::note_instantiation_required_here)
-      << (PrevDecl->getTemplateSpecializationKind() 
+    if (!Okay) {
+      SourceRange Range(TemplateNameLoc, RAngleLoc);
+      Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
+        << Context.getTypeDeclType(Specialization) << Range;
+
+      Diag(PrevDecl->getPointOfInstantiation(), 
+           diag::note_instantiation_required_here)
+        << (PrevDecl->getTemplateSpecializationKind() 
                                                 != TSK_ImplicitInstantiation);
-    return true;
+      return true;
+    }
   }
   
   // If this is not a friend, note that this is an explicit specialization.
@@ -3728,6 +3756,12 @@ Sema::CheckSpecializationInstantiationRedecl(SourceLocation NewLoc,
       //   before the first use of that specialization that would cause an 
       //   implicit instantiation to take place, in every translation unit in
       //   which such a use occurs; no diagnostic is required.
+      for (NamedDecl *Prev = PrevDecl; Prev; Prev = getPreviousDecl(Prev)) {
+        // Is there any previous explicit specialization declaration?
+        if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization)
+          return false;
+      }
+
       Diag(NewLoc, diag::err_specialization_after_instantiation)
         << PrevDecl;
       Diag(PrevPointOfInstantiation, diag::note_instantiation_required_here)
@@ -3756,6 +3790,7 @@ Sema::CheckSpecializationInstantiationRedecl(SourceLocation NewLoc,
       //   of a template appears after a declaration of an explicit 
       //   specialization for that template, the explicit instantiation has no
       //   effect.
+      SuppressNew = true;
       return false;
         
     case TSK_ExplicitInstantiationDefinition:
@@ -4911,18 +4946,21 @@ namespace {
     /// \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).
-    QualType TransformTypenameType(TypeLocBuilder &TLB, TypenameTypeLoc TL);
+    QualType TransformTypenameType(TypeLocBuilder &TLB, TypenameTypeLoc TL, 
+                                   QualType ObjectType);
   };
 }
 
 QualType
 CurrentInstantiationRebuilder::TransformTypenameType(TypeLocBuilder &TLB,
-                                                     TypenameTypeLoc TL) {
+                                                     TypenameTypeLoc TL, 
+                                                     QualType ObjectType) {
   TypenameType *T = TL.getTypePtr();
 
   NestedNameSpecifier *NNS
     = TransformNestedNameSpecifier(T->getQualifier(),
-                              /*FIXME:*/SourceRange(getBaseLocation()));
+                                   /*FIXME:*/SourceRange(getBaseLocation()),
+                                   ObjectType);
   if (!NNS)
     return QualType();