Fix core-DR1755 & 727 & llvm-PR17294 & PR16906 - partial & explicit specializations of member templates (class/variable/function)

[faisalv]

Summary

This patch attempts to address issues related to member template
specializations.

As a quick review (incorporating direction from Issaquah):

1. Full specializations of function, class or variable member templates can be declared at class or namespace scope.

2. Partial specializations of a class or variable member template can be declared similarly.
3. A full or partial specialization, or a primary member template can be explictly declared for an implicitly instantiated class specialization.
   • if the primary template is so explicitly declared it does not inherit partial specializations from the unspecialized prototype template.
   • if a full or partial specialization is so explicitly declared it does but wins out over other specializations that contains fewer empty template parameter lists.

4. Explicitly declared specializations (full or partial) of member templates are only substituted into:
   • a class specialization needs to have its type completed
   • a variable specialization is referenced (to determine type), and then when its value (instantiate initializer) is needed.
   • once a function template is selected, and its declaration is being instantiated.
5. During substitution of any of the explicitly declared partial or full specializations if an error occurs, that declaration is skipped and is not considered either in the partial ordering, or explicit specialization search.

Following are some examples:

 
template<class T, class> struct A {
   template<class U> static A<U, T> var;
   template<class U> static U var<U*>;
   template<> static char var<char>;    
   
   template<class U> struct B {
     template<class V1, class V2> V1* foo(V2);
     template<> typename T::type* foo<typename T::type>(U) { return 0; }
   };
   
   template<class U> struct B<U*>;
};

template<class T, class T2> template<>
struct A<T, T2>::B<typename T::type> { };

template<class T, class T2> template<>
struct A<T, T2>::B<float> { };

template<class T, class T2> template<class U> template<>
char* A<T, T2>::B<U>::foo(T2) { return 0; }

template<> template<class U>
auto A<int>::var<U*> = [](U*) { };

template<> template<class U>
auto A<char>::var = [](U*, char) { };

Additionally, explicitly declared specializations (partial or full) of constexpr
member templates always require an initializer when in-class:

• if they are then declared out of class, it is treated as a definition and can not have an initializer
• For variable templates (and their partial or full specializations) first declared out of line as constexpr they must have an initializer - and subsequently represent a definition.

For class templates, if a partial or full specialization is declared
after a potential use, it is an error.

For variables templates:

• if a partial or full specialization is declared after the 'type' of a variable specialization (that would have used the expicitly declared specialization) has been used, it is only valid if we can prove that the type will be the same.
• When the variable specialization's initializer is needed (that is its value is required), we once again search for the best specialization declaration, and if all is consistent (type matches, value has not been used etc.), we use its value.

Patch Implementation Notes:

I tried to comment the patch with code examples - but the comments do need
improvement. The patch is also short on good diagnostics.

I also introduced checking of class scope function specializations within
a dependent context by generating/inventing template arguments for each
enclosing template parameter list - so that we can compare function
templates, order them (requires their template depth to be zero)
and then link the full-specialization to its appropriate primary
template.

The alternatives were:

1. to postpone all analysis in the dependent context (status quo) and only when the outer template arguments have been substituted, do the analysis of the full specializations (the problem with this is you can write some real non-sense in a dependent context that could never specialize any of your member function templates) and they would always potentially just get SFINAE'd out.
2. consider teaching TemplateDeclInstantiator & TemplateInstantiator to do substitution of template parameters at specific template depths or focus only on certain depths when doing deduction (currently when we do partial ordering, the template delcaration's template parameters must have a depth of 0).

Not sure if I made the right choice, but it seems to work reasonably
well.

I also merged some of the logic for handling partial specializations
of class and variable templates.

Looking forward to some feedback.

Thanks!

[faisalv]

Have partial specializations of variable templates behave similarly to the class partial specializations.

• merges some of the logic of dealing with partial specializations
• member variable templates can be explicitly specialized as primary templates or partial specializations as long as the type does not change or the value has not been used.

Will appreciate any feedback!
thanks

[rsmith]

Sorry for the delay, this hit my spam filter. This patch will need more reviewing than I have time for today, I'll try to come back to it tomorrow or next week. Please ping vigorously if you don't hear from me next week!

[faisalv]

Added support for class scope explicit specializations of member template functions, variables and classes.

Will add a more detailed overview of the changes.

Essentially the following code now works (and similarly for class and variable templates):

template<class T> struct A {

template<class V> V* foo(V*, T*) { return 0; }

};

template<class T> template<>
char* A<T>::foo(char*, T*) { return (char*)(T*)0; }

char *pc = A<int>{}.foo((char*)0, (int*)0);

Please look at the testfile sematemplate/member-templates.cpp for more in depth examples.

Will modify the code once I have feedback!

[faisalv]

no worries Richard - thanks for agreeing to put some time aside for this.

The patch that i just uploaded should implement DR727 too (that is in
class explicit specializations within class templates).

My sense is that it should probably be broken up into smaller patches
...your suggestions here will also be appreciated.

I shall try and write up a paper for core that just summarizes what
was implemented (that might be useful when those issues are discussed
in core (no promises ;))

http://reviews.llvm.org/D3445

Thanks!
Faisal Vali

[faisalv]

Remove some debugging related changes I did not intend to submit.

Sorry about the noise.

[faisalv]

This patch attempts to address issues related to member template
specializations.

As a quick review (incorporating direction from Issaquah):

1. Full specializations of function, class or variable member templates can be declared at class or namespace scope.

2. Partial specializations of a class or variable member template can be declared similarly.
3. A full or partial specialization, or a primary member template can be explictly declared for an implicitly instantiated class specialization.
   • if the primary template is so explicitly declared it does not inherit partial specializations from the unspecialized prototype template.
   • if a full or partial specialization is so explicitly declared it does but wins out over other specializations that contains fewer empty template parameter lists.

4. Explicitly declared specializations (full or partial) of member templates are only substituted into:
   • a class specialization needs to have its type completed
   • a variable specialization is referenced (to determine type), and then when its value (instantiate initializer) is needed.
   • once a function template is selected, and its declaration is being instantiated.
5. During substitution of any of the explicitly declared partial or full specializations if an error occurs, that declaration is skipped and is not considered either in the partial ordering, or explicit specialization search.

Following are some examples:

 
template<class T, class> struct A {
   template<class U> static A<U, T> var;
   template<class U> static U var<U*>;
   template<> static char var<char>;    
   
   template<class U> struct B {
     template<class V1, class V2> V1* foo(V2);
     template<> typename T::type* foo<typename T::type>(U) { return 0; }
   };
   
   template<class U> struct B<U*>;
};

template<class T, class T2> template<>
struct A<T, T2>::B<typename T::type> { };

template<class T, class T2> template<>
struct A<T, T2>::B<float> { };

template<class T, class T2> template<class U> template<>
char* A<T, T2>::B<U>::foo(T2) { return 0; }

template<> template<class U>
auto A<int>::var<U*> = [](U*) { };

template<> template<class U>
auto A<char>::var = [](U*, char) { };

Additionally, explicitly declared specializations (partial or full) of constexpr
member templates always require an initializer when in-class:

• if they are then declared out of class, it is treated as a definition and can not have an initializer
• For variable templates (and their partial or full specializations) first declared out of line as constexpr they must have an initializer - and subsequently represent a definition.

For class templates, if a partial or full specialization is declared
after a potential use, it is an error.

For variables templates:

• if a partial or full specialization is declared after the 'type' of a variable specialization (that would have used the expicitly declared specialization) has been used, it is only valid if we can prove that the type will be the same.
• When the variable specialization's initializer is needed (that is its value is required), we once again search for the best specialization declaration, and if all is consistent (type matches, value has not been used etc.), we use its value.

Patch Implementation Notes:

I tried to comment the patch with code examples - but the comments do need
improvement. The patch is also short on good diagnostics.

I also introduced checking of class scope function specializations within
a dependent context by generating/inventing template arguments for each
enclosing template parameter list - so that we can compare function
templates, order them (requires their template depth to be zero)
and then link the full-specialization to its appropriate primary
template.

The alternatives were:

1. to postpone all analysis in the dependent context (status quo) and only when the outer template arguments have been substituted, do the analysis of the full specializations (the problem with this is you can write some real non-sense in a dependent context that could never specialize any of your member function templates) and they would always potentially just get SFINAE'd out.
2. consider teaching TemplateDeclInstantiator & TemplateInstantiator to do substitution of template parameters at specific template depths or focus only on certain depths when doing deduction (currently when we do partial ordering, the template delcaration's template parameters must have a depth of 0).

Not sure if I made the right choice, but it seems to work reasonably
well.

I also merged some of the logic for handling partial specializations
of class and variable templates.

Looking forward to some feedback.

Thanks!

[faisalv]

*ping* Richard - I know we were thinking about reviewing this in Rapperswil - but couldn't make it work. Any chance I can get you to give me some feedback soon please =)

Also provided is a link to a paper that (might get changed for the pre-rapperswil mailing based on your feedback) summarizes the changes: https://groups.google.com/a/isocpp.org/forum/?fromgroups#!topic/std-discussion/k2yMqp5EnTY

Thanks!

[faisalv]

*ping* Richard please! =)

[faisalv]

*ping*

[rsmith]

Restarted reviewing this, then noticed you've updated it since I last worked on it. Alas. So... you get two different versions of me reviewing the first ~half of this patch :)

include/clang/AST/DeclTemplate.h

668

Maybe isCXXClassMember()?

FIXME: How do we get here for something that's not instantiated from a member?

808–810

This whitespace change doesn't reflect our common practice, which is to put a blank line before public: and no blank line afterwards.

include/clang/Sema/Sema.h

364–370

I don't think we can explicitly specialize in either case. If we needed to instantiate the initializer for any reason, then it's too late to explicitly specialize.

371–372

Can you use the Used flag for this instead?

FIXME: Is this missing serialization?

5295–5297

Do we really need both TemplateParams and TemplateParameterLists?

6086

Please use /// comments here and below.

6087–6093

Doxygenify this:

1. Use ///, not // (here and elsewhere).
2. To apply this doc comment to both following functions, put //@{ on the line before the first function and //@} on the line after the second one.

6088–6090

Seems complex enough that a template<typename Decl> struct MostSpecializedPartialSpecialization would help.

6108–6109

It's generally preferable and conventional to pass in a SmallVectorImpl by reference rather than returning a SmallVector by value, so the caller gets to choose the SmallVector size.

6170–6175

Is this any different from DeducedTemplateArgumentSubstitution?

6174

Wow, that's rather long. Maybe just ExplicitFunctionSpecializationSubstitution?

lib/AST/ASTContext.cpp

7933–7949 ↗

(On Diff #10792)

This should be covered by isThisDeclarationADefinition, shouldn't it? Maybe the problem is in that function instead? This use of A<char>::B<float> should leave A<char>::B<int> as being only a declaration.

lib/AST/Decl.cpp

1752–1753

I'd suggest dropping one of these. Probably the second one.

1764

Does it really matter whether the surrounding class template specialization is implicitly or explicitly instantiated? I would think you just want to know whether it isTemplateInstantiation.

Also, is this just isMemberSpecialization()?

1765

I think MSVC version <old> requires an explicit return type here? Also, this style is not common in Clang and LLVM; we'd usually just use

bool IsVeryLongNameBlahBlah;
{
  // Compute value and initialize.
}

1766

Please use auto when initializing a variable from the result of cast or dyn_cast.

1767–1781

Please factor this out into a static helper function.

1775–1777

Please add a default reference capture, and use the variables you already have for the first two things here.

1783–1797

That's a really weird rule. Maybe we should take this one back to core. It'd be much simpler to apply the current "definition if it has an initializer" rule in all out-of-line cases.

1803

An early bailout if this is false would be better.

1806–1807

Likewise for this.

1808–1816

I think this should simplify somewhat. Looks like the general rule is: if the variable is templated in any way, then it's a definition if the first declaration was within a class, otherwise it's a definition.

lib/AST/DeclTemplate.cpp

1053–1054

Please use

if (auto *D = P->getInstantiatedFromMember())
  if (D->getCanonicalDecl() == DCanon)

(both here and above).

lib/AST/TemplateBase.cpp

24 ↗

(On Diff #9821)

Please do not include Sema into AST.

lib/Sema/SemaDecl.cpp

2853

As before, I think the lambda hurts readability here.

2863

This assertion can fail, for instance if the variable templates are at namespace scope.

[faisalv]

yay! Thanks for the feedback to the first half - will work on it in
the background - looking forward to the rest of the feedback :)
Faisal Vali

include/clang/AST/DeclTemplate.h

 
   /// \brief Note that this member template is a specialization.
   void setMemberSpecialization() {
-    assert(getCommonPtr()->InstantiatedFromMember.getPointer() &&
+    assert(isa<CXXRecordDecl>(getDeclContext()) &&
            "Only member templates can be member template specializations");
     getCommonPtr()->InstantiatedFromMember.setInt(true);
   }

   ///        retrieved by an earlier call to findSpecialization().
   void addSpecialization(FunctionTemplateSpecializationInfo* Info,
                          void *InsertPos);
+public:
+  
 
-public:
   /// Get the underlying function declaration of the template.
   FunctionDecl *getTemplatedDecl() const {
     return static_cast<FunctionDecl*>(TemplatedDecl);

   void setMemberSpecialization() {
     ClassTemplatePartialSpecializationDecl *First =
         cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
-    assert(First->InstantiatedFromMember.getPointer() &&
+
+   assert(isa<CXXRecordDecl>(First->getDeclContext()) &&
            "Only member templates can be member template specializations");
-    return First->InstantiatedFromMember.setInt(true);
+
+    First->InstantiatedFromMember.setInt(true);
   }
 
   /// Retrieves the injected specialization type for this partial

   void setMemberSpecialization() {
     VarTemplatePartialSpecializationDecl *First =
         cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
-    assert(First->InstantiatedFromMember.getPointer() &&
+    assert(isa<CXXRecordDecl>(First->getDeclContext()) &&
            "Only member templates can be member template specializations");
     return First->InstantiatedFromMember.setInt(true);
   }

include/clang/Basic/DiagnosticSemaKinds.td

 def err_partial_spec_ordering_ambiguous : Error<
     "ambiguous partial specializations of %0">;
 def note_partial_spec_match : Note<"partial specialization matches %0">;
+def err_explicit_spec_ordering_ambiguous : Error<
+    "ambiguous explicit specializations of %0">;
+def note_explicit_spec_match : Note<"explicit specialization matches %0">;
 def err_partial_spec_redeclared : Error<
   "class template partial specialization %0 cannot be redeclared">;
 def note_prev_partial_spec_here : Note<

include/clang/Sema/Sema.h

   ///  full expression. 
   llvm::SmallPtrSet<Expr*, 2> MaybeODRUseExprs;
 
+  // Set of all the constexpr variable templates whose values have
+  // been used - this helps us distinguish those variable template
+  // specializations who had their initializers instantiated because
+  // they were needed for 'auto' deduction vs those that were needed
+  // because their value was used.  We can not explicitly specialize
+  // those whose value was actually used - such as the dimension of
+  // an inclass array member etc.
+  llvm::SmallPtrSet<VarTemplateSpecializationDecl *, 8>
+    ConstexprVarTemplateSpecsValueUsed;
+
+  // Set of all dummy (invented) non-type template argument expressions that are
+  // generated when comparing and substituting into dependent class scope
+  // function explicit specializations.
+  // TreeTransform and TemplateArgumentDeduction needs to be able to identify
+  // these nodes so as to handle them specially.
+  llvm::SmallPtrSet<DeclRefExpr *, 8> InventedDummyNonTypeTemplateArguments;
+
+  // FIXME: This hack tracks the instantiation patterns of method
+  // specializations being declared, so that when substituting into the
+  // CXXMethodDecl we can distinguish whether we are in overload resolution vs
+  // doing deduction while declaring a specialization to see if the
+  // specialization is well formed.  A better way is to let the
+  // TemplateDeclInstantiator know when declarations are being finalized either
+  // during the overload-resolution context of a function call vs or while they
+  // are being declared.
+
+  std::vector<CXXMethodDecl *> PatternOfMethodSpecializationBeingDeclared;
+
   /// \brief Stack containing information about each of the nested
   /// function, block, and method scopes that are currently active.
   ///

   DeclResult ActOnVarTemplateSpecialization(
       Scope *S, Declarator &D, TypeSourceInfo *DI,
       SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams,
-      StorageClass SC, bool IsPartialSpecialization);
+      StorageClass SC, bool IsPartialSpecialization, 
+      MultiTemplateParamsArg TemplateParameterLists);
 
   DeclResult CheckVarTemplateId(VarTemplateDecl *Template,
                                 SourceLocation TemplateLoc,

                     const TemplateArgumentListInfo &ExplicitTemplateArgs,
                                                     LookupResult &Previous);
 
+  bool checkDependentClassScopeFunctionExplicitSpecialization(
+    FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs,
+    LookupResult &Previous);
+  
   bool CheckFunctionTemplateSpecialization(FunctionDecl *FD,
                          TemplateArgumentListInfo *ExplicitTemplateArgs,
                                            LookupResult &Previous);

                                            TemplatePartialOrderingContext TPOC,
                                                    unsigned NumCallArguments1,
                                                    unsigned NumCallArguments2);
+
+  // Given a set of function templates, retrieve the most specialized template
+  // as an iterator into the set, or end.
   UnresolvedSetIterator
   getMostSpecialized(UnresolvedSetIterator SBegin, UnresolvedSetIterator SEnd,
                      TemplateSpecCandidateSet &FailedCandidates,

                      const PartialDiagnostic &CandidateDiag,
                      bool Complain = true, QualType TargetType = QualType());
 
+  ClassTemplateSpecializationDecl *
+  getBestExplicitSpecialization(bool &Ambiguous,
+                                ClassTemplateDecl *Template,
+                                ArrayRef<TemplateArgument> TemplateArgs,
+                                SourceLocation PointOfInstantiation);
+
+  VarTemplateSpecializationDecl *
+  getBestExplicitSpecialization(bool &Ambiguous,
+                              VarTemplateDecl *Template,
+                              ArrayRef<TemplateArgument> TemplateArgs,
+                              SourceLocation PointOfInstantiation);
+
   ClassTemplatePartialSpecializationDecl *
   getMoreSpecializedPartialSpecialization(
                                   ClassTemplatePartialSpecializationDecl *PS1,

       VarTemplatePartialSpecializationDecl *PS1,
       VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc);
 
+  // Given a primary template and the supplied template arguments, return in the
+  // form of a tuple:
+  //  1) the best partial specialization
+  //  2) the deduced argument list (can incorporate default arguments not explicitly supplied)
+  //  3) and whether the returned partial specialization is ambiguous.
+  //  If the partial specialization decl is null, none was found, use the primary.
+  
+  std::tuple<ClassTemplatePartialSpecializationDecl *,
+             const TemplateArgumentList *, bool>
+  getMostSpecializedPartialSpecialization(
+      ClassTemplateDecl *D, const TemplateArgumentList &TemplateArgs,
+      SourceLocation PointOfInstantiation);
+  
+  std::tuple<VarTemplatePartialSpecializationDecl *,
+             const TemplateArgumentList *, bool>
+  getMostSpecializedPartialSpecialization(
+      VarTemplateDecl *D, const TemplateArgumentList &TemplateArgs,
+      SourceLocation PointOfInstantiation);
+
+  // Given a var/class/function template declaration - primary, partial, or
+  // explicit retrieve the template parameter lists associated with the
+  // declaration - including all outer scopes if defined inline.
+  SmallVector<TemplateParameterList *, 4>
+  getTemplateParameterListsOfDeclaration(const Decl *D);
+
+  unsigned getNumberOfEmptyTemplateParameterLists(const Decl *D); 
+
   void MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,
                                   bool OnlyDeduced,
                                   unsigned Depth,

   getTemplateInstantiationArgs(NamedDecl *D,
                                const TemplateArgumentList *Innermost = nullptr,
                                bool RelativeToPrimary = false,
-                               const FunctionDecl *Pattern = nullptr);
+                               const FunctionDecl *Pattern = nullptr,
+      const ArrayRef<TemplateParameterList *> TPLsOfDeclBeingSubstituted =
+          ArrayRef<TemplateParameterList *>());
 
   /// \brief A template instantiation that is currently in progress.
   struct ActiveTemplateInstantiation {

include/clang/Sema/SemaInternal.h

 #include "clang/AST/ASTContext.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaDiagnostic.h"
+#include "clang/Sema/TemplateDeduction.h"
 
 namespace clang {
 

 
   Var->markUsed(SemaRef.Context);
 }
+Sema::TemplateDeductionResult
+DeduceTemplateArgumentsByTypeMatchForExplicitSpecializations(
+    Sema &S, FunctionTemplateDecl *PrimaryTemplate,
+    CXXMethodDecl *SubstitutedExplicitSpecialization,
+    TemplateArgumentListInfo *SubstitutedExplicitTemplateArgs,
+    sema::TemplateDeductionInfo &Info,
+    SmallVectorImpl<DeducedTemplateArgument> &Deduced);
 }
 
 #endif

include/clang/Sema/Template.h

     Sema::LateInstantiatedAttrVec* LateAttrs;
     LocalInstantiationScope *StartingScope;
 
-    /// \brief A list of out-of-line class template partial
-    /// specializations that will need to be instantiated after the
-    /// enclosing class's instantiation is complete.
-    SmallVector<std::pair<ClassTemplateDecl *,
-                                ClassTemplatePartialSpecializationDecl *>, 4>
-      OutOfLinePartialSpecs;
-
-    /// \brief A list of out-of-line variable template partial
-    /// specializations that will need to be instantiated after the
-    /// enclosing variable's instantiation is complete.
-    /// FIXME: Verify that this is needed.
-    SmallVector<
-        std::pair<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>, 4>
-    OutOfLineVarPartialSpecs;
-
   public:
     TemplateDeclInstantiator(Sema &SemaRef, DeclContext *Owner,
                              const MultiLevelTemplateArgumentList &TemplateArgs)

 #include "clang/AST/DeclNodes.inc"
 
     // A few supplemental visitor functions.
+    Decl *
+    VisitFunctionTemplateDecl(FunctionTemplateDecl *D,
+                              bool IsCheckingDependentClassScopeSpecialization);
     Decl *VisitCXXMethodDecl(CXXMethodDecl *D,
                              TemplateParameterList *TemplateParams,
                              bool IsClassScopeSpecialization = false);

 
     LocalInstantiationScope *getStartingScope() const { return StartingScope; }
 
-    typedef 
-      SmallVectorImpl<std::pair<ClassTemplateDecl *,
-                                     ClassTemplatePartialSpecializationDecl *> >
-        ::iterator
-      delayed_partial_spec_iterator;
-
-    typedef SmallVectorImpl<std::pair<
-        VarTemplateDecl *, VarTemplatePartialSpecializationDecl *> >::iterator
-    delayed_var_partial_spec_iterator;
-
-    /// \brief Return an iterator to the beginning of the set of
-    /// "delayed" partial specializations, which must be passed to
-    /// InstantiateClassTemplatePartialSpecialization once the class
-    /// definition has been completed.
-    delayed_partial_spec_iterator delayed_partial_spec_begin() {
-      return OutOfLinePartialSpecs.begin();
-    }
-
-    delayed_var_partial_spec_iterator delayed_var_partial_spec_begin() {
-      return OutOfLineVarPartialSpecs.begin();
-    }
-
-    /// \brief Return an iterator to the end of the set of
-    /// "delayed" partial specializations, which must be passed to
-    /// InstantiateClassTemplatePartialSpecialization once the class
-    /// definition has been completed.
-    delayed_partial_spec_iterator delayed_partial_spec_end() {
-      return OutOfLinePartialSpecs.end();
-    }
-
-    delayed_var_partial_spec_iterator delayed_var_partial_spec_end() {
-      return OutOfLineVarPartialSpecs.end();
-    }
-
     // Helper functions for instantiating methods.
     TypeSourceInfo *SubstFunctionType(FunctionDecl *D,
                              SmallVectorImpl<ParmVarDecl *> &Params);

lib/AST/Decl.cpp

     if (isOutOfLine() &&
         (hasInit() ||
          // If the first declaration is out-of-line, this may be an
-         // instantiation of an out-of-line partial specialization of a variable
-         // template for which we have not yet instantiated the initializer.
+         // instantiation of an out-of-line partial or explicit specialization
+         // of a variable template for which we have not yet instantiated
+         // the initializer.
          (getFirstDecl()->isOutOfLine()
               ? getTemplateSpecializationKind() == TSK_Undeclared
               : getTemplateSpecializationKind() !=
                     TSK_ExplicitSpecialization) ||
-         isa<VarTemplatePartialSpecializationDecl>(this)))
+         // isa<VarTemplatePartialSpecializationDecl>(this) ||
+         // Since Both partial and explicit specializations are marked
+         // TSK_ExplicitSpecializations, we handle them both here.
+         (isa<VarTemplateSpecializationDecl>(this) &&
+          getTemplateSpecializationKind() == TSK_ExplicitSpecialization)))
       return Definition;
     else
       return DeclarationOnly;

lib/AST/DeclTemplate.cpp

             P = getPartialSpecializations().begin(),
          PEnd = getPartialSpecializations().end();
        P != PEnd; ++P) {
-    if (P->getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
-      return P->getMostRecentDecl();
+    if (ClassTemplatePartialSpecializationDecl *ProtoPSpec =
+            P->getInstantiatedFromMember()) {
+      if (ProtoPSpec->getCanonicalDecl() == DCanon)
+        return P->getMostRecentDecl();
+    }
   }
-
   return 0;
 }
 

   return Result;
 }
 
+
 //===----------------------------------------------------------------------===//
 // FriendTemplateDecl Implementation
 //===----------------------------------------------------------------------===//

            P = getPartialSpecializations().begin(),
            PEnd = getPartialSpecializations().end();
        P != PEnd; ++P) {
-    if (P->getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
-      return P->getMostRecentDecl();
+    if (P->getInstantiatedFromMember())
+      if (P->getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
+        return P->getMostRecentDecl();
   }
 
   return 0;

lib/Sema/SemaDecl.cpp

 
   QualType MergedT;
   if (getLangOpts().CPlusPlus) {
+    const bool IsMemberVariableTemplateBeingExplicitlySpecialized =
+        ([](VarDecl *New, VarDecl *Old) {
+          if (VarTemplateDecl *NewVT = New->getDescribedVarTemplate()) {
+            VarTemplateDecl *OldVT = Old->getDescribedVarTemplate();
+            assert(OldVT && "If the new declaration is a variable template, so "
+                            "should the old template be!");
+            // FIXME: There is no way to safely call getInstFromMemTempl or
+            // isMemberSpecialization on NewVT - since both those functions
+            // have the side-effect of creating a shared Common ptr
+            // that is not correctly wired up if the Old and New vars
+            // need to be redecl connected.  Consider passing in the
+            // IsExplicitSpecialization determination in
+            // Sema::ActOnVariableDeclarator
+            // into MergeVarDeclTypes (i.e. current function).
+            return !!OldVT->getInstantiatedFromMemberTemplate(); 
+          }
+          return false;
+        }(New, Old));
+
     if (New->getType()->isUndeducedType()) {
       // We don't know what the new type is until the initializer is attached.
       return;
     } else if (Context.hasSameType(New->getType(), Old->getType())) {
-      // These could still be something that needs exception specs checked.
-      return MergeVarDeclExceptionSpecs(New, Old);
+      // If this is a member variable template, make sure the primary
+      // template has not been used.
+      // template<class T> struct A {
+      //   template<class U> static constexpr int b = 3;
+      //   template<class U> static constexpr int b<U*> = 30;
+      //   int m[b<T*>];
+      // };
+      // template<> template<class U>
+      // constexpr int A<short>::b = 10;
+      // 
+      // The above is not fine since the partial specialization is used
+      // and when we explicitly specialize the primary template had it been
+      // seen before the use, it would have been used, and not the partial
+      // specialization.
+      if (IsMemberVariableTemplateBeingExplicitlySpecialized) {
+        VarTemplateDecl *NewVT = New->getDescribedVarTemplate();
+        VarTemplateDecl *OldVT = Old->getDescribedVarTemplate();
+        // The specialization that conflicts with this explicit 
+        // specialization.
+        VarTemplateSpecializationDecl *InstConflictVSpec = nullptr;
+        const bool PrimaryTemplateWasUsedOrPartialSpecializationReferenced =
+            [OldVT, Old, &InstConflictVSpec](Sema & SemaRef) {
+              for (VarTemplateSpecializationDecl *VSpec :
+                   OldVT->specializations()) {
+
+                // If any specialization was referenced - we can
+                // not subsequently explicitly specialize the primary template.
+
+                // If any specialization was instantiated using a partial
+                // specialization - it might have a different type, so we
+                // can not use it.
+                // FIXME: check the type, if it does have a diff type we can not
+                // explicitly specialize the primary template.  Although, you
+                // would have to instantiate NewVT with the template arguments
+                // of VSpec to be sure - for now since this has not been
+                // discussed by core - if a specialization uses a non-explicitly
+                // specialized partial spec, we do not allow explicit spec of
+                // the primary.
+
+                if (VSpec->isUsed() ||
+                    SemaRef.ConstexprVarTemplateSpecsValueUsed.count(VSpec) ||
+                     VSpec->getSpecializedTemplateOrPartial()
+                        .is<VarTemplatePartialSpecializationDecl *>()) {
+                  InstConflictVSpec = VSpec;
+                  return true;
+                }
+              }
+              return false;
+            }(*this);
+        if (!PrimaryTemplateWasUsedOrPartialSpecializationReferenced)
+          return MergeVarDeclExceptionSpecs(New, Old);
+        else { 
+          // Complain that we are trying to explicitly specialize a variable 
+          // member template after it has already been used and its initializer
+          // has been instantiated!
+          // FIXME: In case of a partial specialization being referenced and 
+          // then a primary template being explicitly specialized, the diagnostic
+          // is misleading.
+          SourceRange Range(New->getLocStart(), New->getLocEnd());
+          Diag(New->getLocation(), diag::err_specialization_after_instantiation)
+              << New->getName() << Range;
+
+          Diag(InstConflictVSpec->getPointOfInstantiation(),
+               diag::note_instantiation_required_here)
+              << 0;
+          return New->setInvalidDecl();
+        }
+      } else {
+        // These could still be something that needs exception specs checked.
+        return MergeVarDeclExceptionSpecs(New, Old);
+      }
     }
     // C++ [basic.link]p10:
     //   [...] the types specified by all declarations referring to a given

                Old->getType()->isObjCObjectPointerType()) {
       MergedT = Context.mergeObjCGCQualifiers(New->getType(),
                                               Old->getType());
+    } else if (IsMemberVariableTemplateBeingExplicitlySpecialized) {
+      // If we are adding an explicit specialization of a variable template,
+      // set the old type to the new type - only if the old template has
+      // not been instantiated - for e.g.
+      // template<class T> struct A {
+      //   template<class U> static constexpr int b = 1;
+      //   decltype(b<T>) constexpr foo() { return 0; };
+      //   decltype(b<T>) member;
+      // };
+      // template<> template<class U>
+      // constexpr float A<short>::b = 2.0;
+      //   - When A<short> is implicitly instantiated, prior to the new 'b'
+      //   variable template being declared the old 'b' instantiated in
+      //   A<short> gets used in the definition of A<short> and so can not
+      //   be explicitly specialized again.
+      // FIXME: the diagnostic should state that a different specialization
+      // type is being specified.
+      VarTemplateDecl *OldVT = Old->getDescribedVarTemplate();
+      if (OldVT->spec_begin() == OldVT->spec_end()) {
+        Old->setType(New->getType());
+        return;
+      }
+
+      VarTemplateSpecializationDecl *InstConflictVSpec = *OldVT->spec_begin();
+      SourceRange Range(New->getLocStart(), New->getLocEnd());
+      Diag(New->getLocation(), diag::err_specialization_after_instantiation)
+        << New->getName() << Range;
+
+      Diag(InstConflictVSpec->getPointOfInstantiation(),
+        diag::note_instantiation_required_here)
+        << 0;
+      return New->setInvalidDecl();
     }
   } else {
     // C 6.2.7p2:

   CXXScopeSpec &SS = DS.getTypeSpecScope();
   bool IsExplicitSpecialization =
     !TemplateParams.empty() && TemplateParams.back()->size() == 0;
+
+  // We allow (re-)declarations of member template specializations at namespace
+  // scope.
+  // Per C++-N3936 [14.5.5 temp.class.spec]p5
+  //    A class template partial specialization may be declared or redeclared in
+  //    any namespace scope in which its definition may be defined (14.5.1 and
+  //    14.5.2).
+  //  template<class T> struct A {
+  //    template<class U> struct B { };
+  //  };
+  //  template<class T> template <class U> struct A<T>::B<U*>;  #1
+  //  template<> template<class U> struct A<int>::B<U*>;        #2
+  //  template<> template<> struct A<int>::B<int*>;             #3
+  const bool
+  IsMemberTemplateSpecializationDeclarationSansDefinition = [&Tag, &SS] {
+    const auto *const RD = dyn_cast_or_null<CXXRecordDecl>(Tag);
+    if (RD && SS.isNotEmpty() && isa<CXXRecordDecl>(RD->getDeclContext()) &&
+        !RD->isCompleteDefinition()) {
+      // Catch #1, #2 above.
+      if (isa<ClassTemplatePartialSpecializationDecl>(RD))  
+        return true;
+      // Catch #3 above.
+      if (isa<ClassTemplateSpecializationDecl>(RD) &&       
+          RD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization)
+        return true;
+    }
+    return false;
+  }();
+
   if (Tag && SS.isNotEmpty() && !Tag->isCompleteDefinition() &&
-      !IsExplicitInstantiation && !IsExplicitSpecialization) {
+      !IsExplicitInstantiation && !IsExplicitSpecialization &&
+      !IsMemberTemplateSpecializationDeclarationSansDefinition) {
     // Per C++ [dcl.type.elab]p1, a class declaration cannot have a
     // nested-name-specifier unless it is an explicit instantiation
     // or an explicit specialization.

               : SourceLocation();
       DeclResult Res = ActOnVarTemplateSpecialization(
           S, D, TInfo, TemplateKWLoc, TemplateParams, SC,
-          IsPartialSpecialization);
+          IsPartialSpecialization, TemplateParamLists);
       if (Res.isInvalid())
         return 0;
       NewVD = cast<VarDecl>(Res.get());

       NewVD->setInvalidDecl();
     }
 
-    if (!IsVariableTemplateSpecialization)
+    if (!IsVariableTemplateSpecialization) {      
       D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
     
+      // We must do this AFTER previous-decl links have been set through
+      // CheckVariableDeclaration, or else the common-stuff that should
+      // be reshared across redecls gets miswired.
+      if (IsExplicitSpecialization && NewTemplate) {
+        NewTemplate->setMemberSpecialization();
+      }
+    }
     if (NewTemplate) {
       VarTemplateDecl *PrevVarTemplate =
           NewVD->getPreviousDecl()

                                                        Previous))
         NewFD->setInvalidDecl();
     } else if (isFunctionTemplateSpecialization) {
-      if (CurContext->isDependentContext() && CurContext->isRecord() 
+      DeclContext *const SemanticDC = NewFD->getDeclContext();
+      if (SemanticDC->isDependentContext() && SemanticDC->isRecord() 
           && !isFriend) {
         isDependentClassScopeExplicitSpecialization = true;
-        Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ? 
-          diag::ext_function_specialization_in_class :
-          diag::err_function_specialization_in_class)
-          << NewFD->getDeclName();
+        // In C++14+ per DR727 - explicit specializations are allowed at class
+        // scope.
+        if (!getLangOpts().CPlusPlus1y) {
+          Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ? 
+            diag::ext_function_specialization_in_class :
+            diag::err_function_specialization_in_class)
+            << NewFD->getDeclName();
+        } else if (checkDependentClassScopeFunctionExplicitSpecialization(
+                       NewFD, (HasExplicitTemplateArgs ? &TemplateArgs : 0),
+                       Previous))
+          NewFD->setInvalidDecl();
       } else if (CheckFunctionTemplateSpecialization(NewFD,
                                   (HasExplicitTemplateArgs ? &TemplateArgs : 0),
                                                      Previous))

       }
       
     } else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD)) {
+      // template<class T> struct A {
+      //   template<class U> U* foo(U*, T*) { return 0; }
+      // };
+      // template<> template<class U>
+      //  U* A<int>::foo(U*, int*) { return 0; }
+      // 
       if (CheckMemberSpecialization(NewFD, Previous))
           NewFD->setInvalidDecl();
     }

 
       if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
         CheckMSVCRTEntryPoint(NewFD);
-
-      if (!NewFD->isInvalidDecl())
-        D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
+    }
                                                     isExplicitSpecialization));
-    }
+    
 
     assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
             Previous.getResultKind() != LookupResult::FoundOverloaded) &&

       // Qualified decls generally require a previous declaration.
       if (D.getCXXScopeSpec().isSet()) {
         // ...with the major exception of templated-scope or
-        // dependent-scope friend declarations.
+        // dependent-scope friend declarations and explicit
+        // specializations of member function templates.
 
         // TODO: we currently also suppress this check in dependent
         // contexts because (1) the parameter depth will be off when

              D.getCXXScopeSpec().getScopeRep()->isDependent() ||
              CurContext->isDependentContext())) {
           // ignore these
+        } else if (isDependentClassScopeExplicitSpecialization &&
+                   NewFD->isOutOfLine()) {
+          // these can be first declared out of line - so ignore these.
         } else {
           // The user tried to provide an out-of-line definition for a
           // function that is a member of a class or namespace, but there

   if (isDependentClassScopeExplicitSpecialization) {
     ClassScopeFunctionSpecializationDecl *NewSpec =
                          ClassScopeFunctionSpecializationDecl::Create(
-                                Context, CurContext, SourceLocation(), 
+                                Context, CurContext, NewFD->getLocStart(), 
                                 cast<CXXMethodDecl>(NewFD),
                                 HasExplicitTemplateArgs, TemplateArgs);
     CurContext->addDecl(NewSpec);

     // data members we also need to check whether there was an in-class
     // declaration with an initializer.
     if (VDecl->isStaticDataMember() && VDecl->getAnyInitializer(PrevInit)) {
-      Diag(Init->getExprLoc(), diag::err_static_data_member_reinitialization)
-          << VDecl->getDeclName();
-      Diag(PrevInit->getInit()->getExprLoc(), diag::note_previous_initializer) << 0;
-      return;
+      // ... except for static constexpr auto variable templates if they are
+      // being explicitly specialized.
+      if (const bool
+              IsNotAutoVarMemberTemplateBeingExplicitlySpecialized =
+                  !([](Sema &SemaRef, VarDecl *VDecl) {
+                    if (VarTemplateDecl *NewVT =
+                            VDecl->getDescribedVarTemplate()) {
+                      const bool IsMemberTemplateBeingExplicitlySpecialized =
+                          NewVT->isMemberSpecialization();
+                      const bool IsAutoVarTemplate =
+                          VDecl->getType()->getContainedAutoType();
+                      return IsMemberTemplateBeingExplicitlySpecialized &&
+                             IsAutoVarTemplate;
+                    }
+                    return false;
+                  })(*this, VDecl)) {
+        Diag(Init->getExprLoc(), diag::err_static_data_member_reinitialization)
+            << VDecl->getDeclName();
+        Diag(PrevInit->getInit()->getExprLoc(), diag::note_previous_initializer) << 0;
+        return;
+      } else {
+        // Adjust the initializer of the previous instantiated-from member decls
+        // since it has been supplanted by the explicit specialization.
+        for (auto *D : VDecl->redecls()) {
+          if (D == PrevInit)
+            D->setInit(Init);
+        }
+      }
     }  
 
     if (VDecl->hasLocalStorage())

lib/Sema/SemaExpr.cpp

           // Do not defer instantiations of variables which could be used in a
           // constant expression.
           SemaRef.InstantiateVariableDefinition(PointOfInstantiation, Var);
+          // Mark specializations of variable templates that are constexpr
+          // and evaluated - so that we can distinguish that the initializer
+          // was instantiated not just for auto type deduction (in the cases
+          // where we need to know if the variable was truly referenced so
+          // we can not explicitly specialize it after the fact).
+          // For e.g.
+          //   template<class T> struct A {
+          //     template <class U> 
+          //        static constexpr auto b = U{1}; <-- #1
+          //     int mem[b<T>];   <-- #2
+          //  };
+          //  template<> template<class U>
+          //    constexpt auto A<short>::b = U{2}; <-- #3.
+          //  if #2 is commented out, the above should be ok, else
+          //  #1 is marked as used below, and prevents declaration of #3.
+          //   
+          if (auto *VSpec = dyn_cast<VarTemplateSpecializationDecl>(Var))
+            SemaRef.ConstexprVarTemplateSpecsValueUsed.insert(VSpec);
         } else {
           SemaRef.PendingInstantiations
               .push_back(std::make_pair(Var, PointOfInstantiation));

lib/Sema/SemaTemplate.cpp

   // 'template<>' headers, this will be set to the location of that
   // explicit specialization.
   SourceLocation ExplicitSpecLoc;
-  
   while (!T.isNull()) {
     NestedTypes.push_back(T);
-    
     // Retrieve the parent of a record type.
     if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) {
-      // If this type is an explicit specialization, we're done.
-      if (ClassTemplateSpecializationDecl *Spec
-          = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
-        if (!isa<ClassTemplatePartialSpecializationDecl>(Spec) && 
-            Spec->getSpecializationKind() == TSK_ExplicitSpecialization) {
+      // If this type is an explicit specialization within a non-dependent
+      // context, we're done.
+      if (ClassTemplateSpecializationDecl *Spec =
+              dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
+        if (!isa<ClassTemplatePartialSpecializationDecl>(Spec) &&
+            Spec->getSpecializationKind() == TSK_ExplicitSpecialization &&
+            !Spec->isDependentContext()
+            ) {
           ExplicitSpecLoc = Spec->getLocation();
           break;
         }

   //   explicitly specialized.
   bool SawNonEmptyTemplateParameterList = false;
 
-  auto CheckExplicitSpecialization = [&](SourceRange Range, bool Recovery) {
-    if (SawNonEmptyTemplateParameterList) {
-      Diag(DeclLoc, diag::err_specialize_member_of_template)
-        << !Recovery << Range;
+  auto CheckExplicitSpecialization = [&](SourceRange Range, bool Recovery,
+                                         bool IsLastTPL) {
+    if (SawNonEmptyTemplateParameterList && !IsLastTPL) {
+      Diag(DeclLoc, diag::err_specialize_member_of_template) << !Recovery
+                                                             << Range;
       Invalid = true;
       IsExplicitSpecialization = false;
       return true;

 
   auto DiagnoseMissingExplicitSpecialization = [&] (SourceRange Range) {
     // Check that we can have an explicit specialization here.
-    if (CheckExplicitSpecialization(Range, true))
+    if (CheckExplicitSpecialization(Range, true, false))
       return true;
 
     // We don't have a template header, but we should.

     if (ParamIdx < ParamLists.size()) {
       if (ParamLists[ParamIdx]->size() == 0) {
         if (CheckExplicitSpecialization(ParamLists[ParamIdx]->getSourceRange(),
-                                        false))
+                                        false, ParamLists.size() == ParamIdx + 1))
           return 0;
       } else
         SawNonEmptyTemplateParameterList = true;

   //   are not explicitly specialized as well.
   if (ParamLists.back()->size() == 0 &&
       CheckExplicitSpecialization(ParamLists[ParamIdx]->getSourceRange(),
-                                  false))
+                                  false, true))
     return 0;
 
   // Return the last template parameter list, which corresponds to the

     // TODO: in theory this could be a simple hashtable lookup; most
     // changes to CurContext don't change the set of current
     // instantiations.
-    if (isa<ClassTemplateDecl>(Template)) {
+    if (ClassTemplateDecl *ClassTemplate =
+            dyn_cast<ClassTemplateDecl>(Template)) {
+      bool IsInjectedType = false;
       for (DeclContext *Ctx = CurContext; Ctx; Ctx = Ctx->getLookupParent()) {
         // If we get out to a namespace, we're done.
         if (Ctx->isFileContext()) break;

         QualType ICNT = Context.getTypeDeclType(Record);
         QualType Injected = cast<InjectedClassNameType>(ICNT)
           ->getInjectedSpecializationType();
-
         if (CanonType != Injected->getCanonicalTypeInternal())
           continue;
 

         // class name type of the record we just found.
         assert(ICNT.isCanonical());
         CanonType = ICNT;
+        IsInjectedType = true;
         break;
       }
+      if (!IsInjectedType) {
+        // If not the injected type of the current template, search for
+        // a specialization (such as a class scope explicit specialization
+        // within a dependent context)
+        void *InsertPos = nullptr;
+        ClassTemplateSpecializationDecl *Decl
+          = ClassTemplate->findSpecialization(Converted.data(), Converted.size(),
+                                          InsertPos);
+        if (Decl) {
+          CanonType = Context.getTypeDeclType(Decl);      
+        }
+      }
     }
+
   } else if (ClassTemplateDecl *ClassTemplate
                = dyn_cast<ClassTemplateDecl>(Template)) {
     // Find the class template specialization declaration that

                                           InsertPos);
     if (!Decl) {
       // 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,
+      // specialization. Check if we have an explicit specialization.
+      bool Ambiguous = false;
+      Decl = getBestExplicitSpecialization(
+          Ambiguous, ClassTemplate,
+          ArrayRef<TemplateArgument>(Converted.data(), Converted.size()),
+          TemplateLoc);
+
+      if (Ambiguous)
+        return QualType();
+
+      if (!Decl) {
+        // Create the canonical declaration and add it to
+        // the set of specializations.
+        Decl = ClassTemplateSpecializationDecl::Create(Context,
                             ClassTemplate->getTemplatedDecl()->getTagKind(),
                                                 ClassTemplate->getDeclContext(),
                             ClassTemplate->getTemplatedDecl()->getLocStart(),

                                                      ClassTemplate,
                                                      Converted.data(),
                                                      Converted.size(), 0);
+        
+      }
       ClassTemplate->AddSpecialization(Decl, InsertPos);
       if (ClassTemplate->isOutOfLine())
         Decl->setLexicalDeclContext(ClassTemplate->getLexicalDeclContext());

 DeclResult Sema::ActOnVarTemplateSpecialization(
     Scope *S, Declarator &D, TypeSourceInfo *DI, SourceLocation TemplateKWLoc,
     TemplateParameterList *TemplateParams, VarDecl::StorageClass SC,
-    bool IsPartialSpecialization) {
+    bool IsPartialSpecialization,
+    MultiTemplateParamsArg TemplateParameterLists) {
   // D must be variable template id.
   assert(D.getName().getKind() == UnqualifiedId::IK_TemplateId &&
          "Variable template specialization is declared with a template it.");

             Context, VarTemplate->getDeclContext(), TemplateKWLoc,
             TemplateNameLoc, TemplateParams, VarTemplate, DI->getType(), DI, SC,
             Converted.data(), Converted.size(), TemplateArgs);
     
-    if (!PrevPartial)
+    const bool HasEmptyTemplateParameterLists = ([](
+        ArrayRef<TemplateParameterList *> TPLs) {
+      for (auto *TPL : TPLs)
+        if (!TPL->size())
+          return true;
+      return false;
+    })(TemplateParameterLists);
+    
+    if (!PrevPartial) 
       VarTemplate->AddPartialSpecialization(Partial, InsertPos);
+      
     Specialization = Partial;
     
+    if (HasEmptyTemplateParameterLists && PrevPartial) {
+      // This is an error: Explicitly specialized partial specializations can
+      // not have previous declaration for variable templates, since each 
+      // explicitly specialized partial specialization has to be a definition.
+      // We do not need to do anything about this here - since this gets 
+      // caught by the machinery that checks for invalidity of redefinitions.
+      assert(CurContext != PrevPartial->/*getSemanticDC*/getDeclContext() &&
+             "A redefintion of a variable template, though invalid and marked "
+             "as such later, should only be possible when we are declaring it "
+             "out of line");
+    }
     // If we are providing an explicit specialization of a member variable
     // template specialization, make a note of that.
-    if (PrevPartial && PrevPartial->getInstantiatedFromMember())
-      PrevPartial->setMemberSpecialization();
+    if (HasEmptyTemplateParameterLists)
+      Partial->setMemberSpecialization();
 
     // Check that all of the template parameters of the variable template
     // partial specialization are deducible from the template

         }
       }
     }
+    // Check to see if VarTemplateDecl has any instantiations (make sure
+    // they are implicitly instantiated and not explicit specializations) that
+    // would use this partial specialization, and if so, this is an error!
+    if (!PrevDecl) {
+      VarTemplateSpecializationDecl *const InstThatWouldHaveUsedPartialSpec =
+          ([VarTemplate, Partial](SourceLocation PointOfInstantiation,
+                                  Sema &SemaRef) {
+            for (VarTemplateSpecializationDecl *Spec :
+                 VarTemplate->specializations()) {
+              if (Spec->getTemplateSpecializationKind() ==
+                  TSK_ExplicitSpecialization)
+                continue;
+              const TemplateArgumentList &TemplateArgs =
+                  Spec->getTemplateArgs();
+              TemplateDeductionInfo Info(PointOfInstantiation);
+              if (Sema::TemplateDeductionResult Result =
+                      SemaRef.DeduceTemplateArguments(Partial, TemplateArgs,
+                                                      Info)) {
+                /* we could not have used this partial specialization so
+                 * ignore...*/
+              } else {
+                return Spec;
+              }
+            }
+            return (VarTemplateSpecializationDecl *)nullptr;
+          }(D.getLocStart(), *this));
+
+      if (InstThatWouldHaveUsedPartialSpec) {
+        SourceRange Range(TemplateNameLoc, RAngleLoc);
+        Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
+            << Name << Range;
+
+        Diag(InstThatWouldHaveUsedPartialSpec->getPointOfInstantiation(),
+             diag::note_instantiation_required_here)
+            << 0;
+      }
+    }
+
   } else {
     // Create a new class template specialization declaration node for
     // this explicit specialization or friend declaration.

   return Specialization;
 }
 
-namespace {
-/// \brief A partial specialization whose template arguments have matched
-/// a given template-id.
-struct PartialSpecMatchResult {
-  VarTemplatePartialSpecializationDecl *Partial;
-  TemplateArgumentList *Args;
-};
-}
-
 DeclResult
 Sema::CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc,
                          SourceLocation TemplateNameLoc,
                          const TemplateArgumentListInfo &TemplateArgs) {
   assert(Template && "A variable template id without template?");
-
+  const SourceLocation PointOfInstantiation = TemplateNameLoc;
   // Check that the template argument list is well-formed for this template.
   SmallVector<TemplateArgument, 4> Converted;
   if (CheckTemplateArgumentList(

 
   // Find the variable template specialization declaration that
   // corresponds to these arguments.
+  
   void *InsertPos = 0;
   if (VarTemplateSpecializationDecl *Spec = Template->findSpecialization(
           Converted.data(), Converted.size(), InsertPos))
     // If we already have a variable template specialization, return it.
     return Spec;
   
+  bool AmbiguousExplicitSpec = false; 
+  
+  if (VarTemplateSpecializationDecl *Spec = getBestExplicitSpecialization(
+          AmbiguousExplicitSpec, Template, Converted, PointOfInstantiation)) {
+    if (AmbiguousExplicitSpec) {
+      Spec->setInvalidDecl();
+      return true;
+    }
+    Template->AddSpecialization(Spec, InsertPos);
+    return Spec;
+  }
   // This is the first time we have referenced this variable template
   // specialization. Create the canonical declaration and add it to
   // the set of specializations, based on the closest partial specialization

   VarDecl *InstantiationPattern = Template->getTemplatedDecl();
   TemplateArgumentList TemplateArgList(TemplateArgumentList::OnStack,
                                        Converted.data(), Converted.size());
-  TemplateArgumentList *InstantiationArgs = &TemplateArgList;
-  bool AmbiguousPartialSpec = false;
-  typedef PartialSpecMatchResult MatchResult;
-  SmallVector<MatchResult, 4> Matched;
-  SourceLocation PointOfInstantiation = TemplateNameLoc;
+  const TemplateArgumentList *InstantiationArgs = &TemplateArgList;
+
+  
+  
   TemplateSpecCandidateSet FailedCandidates(PointOfInstantiation);
 
   // 1. Attempt to find the closest partial specialization that this

   //       Perhaps better after unification of DeduceTemplateArguments() and
   //       getMoreSpecializedPartialSpecialization().
   bool InstantiationDependent = false;
+  bool AmbiguousPartialSpec = false;
+  
   if (!TemplateSpecializationType::anyDependentTemplateArguments(
           TemplateArgs, InstantiationDependent)) {
-
-    SmallVector<VarTemplatePartialSpecializationDecl *, 4> PartialSpecs;
-    Template->getPartialSpecializations(PartialSpecs);
-
-    for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
-      VarTemplatePartialSpecializationDecl *Partial = PartialSpecs[I];
-      TemplateDeductionInfo Info(FailedCandidates.getLocation());
-
-      if (TemplateDeductionResult Result =
-              DeduceTemplateArguments(Partial, TemplateArgList, Info)) {
-        // Store the failed-deduction information for use in diagnostics, later.
-        // TODO: Actually use the failed-deduction info?
-        FailedCandidates.addCandidate()
-            .set(Partial, MakeDeductionFailureInfo(Context, Result, Info));
-        (void)Result;
-      } else {
-        Matched.push_back(PartialSpecMatchResult());
-        Matched.back().Partial = Partial;
-        Matched.back().Args = Info.take();
-      }
-    }
-
-    if (Matched.size() >= 1) {
-      SmallVector<MatchResult, 4>::iterator Best = Matched.begin();
-      if (Matched.size() == 1) {
-        //   -- If exactly one matching specialization is found, the
-        //      instantiation is generated from that specialization.
-        // We don't need to do anything for this.
-      } else {
-        //   -- If more than one matching specialization is found, the
-        //      partial order rules (14.5.4.2) are used to determine
-        //      whether one of the specializations is more specialized
-        //      than the others. If none of the specializations is more
-        //      specialized than all of the other matching
-        //      specializations, then the use of the variable template is
-        //      ambiguous and the program is ill-formed.
-        for (SmallVector<MatchResult, 4>::iterator P = Best + 1,
-                                                   PEnd = Matched.end();
-             P != PEnd; ++P) {
-          if (getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial,
-                                                      PointOfInstantiation) ==
-              P->Partial)
-            Best = P;
-        }
-
-        // Determine if the best partial specialization is more specialized than
-        // the others.
-        for (SmallVector<MatchResult, 4>::iterator P = Matched.begin(),
-                                                   PEnd = Matched.end();
-             P != PEnd; ++P) {
-          if (P != Best && getMoreSpecializedPartialSpecialization(
-                               P->Partial, Best->Partial,
-                               PointOfInstantiation) != Best->Partial) {
-            AmbiguousPartialSpec = true;
-            break;
-          }
-        }
-      }
-
+    VarTemplatePartialSpecializationDecl *BestPartialSpec = nullptr;
+    const TemplateArgumentList *BestPartialDeducedArgs = nullptr;
+    std::tie(BestPartialSpec, BestPartialDeducedArgs, AmbiguousPartialSpec) =
+        getMostSpecializedPartialSpecialization(Template, TemplateArgList,
+                                                PointOfInstantiation);
+    // Determine the best partial specialization to use, if one exists.
+    // If the search was ambiguous, then complain, mark
+    // AmbiguousPartialSpec as true and return one of the ambiguous
+    // specializations - so that we can error gracefully.
+    if (BestPartialSpec) {
       // Instantiate using the best variable template partial specialization.
-      InstantiationPattern = Best->Partial;
-      InstantiationArgs = Best->Args;
-    } else {
-      //   -- If no match is found, the instantiation is generated
-      //      from the primary template.
-      // InstantiationPattern = Template->getTemplatedDecl();
+      InstantiationPattern = BestPartialSpec;
+      InstantiationArgs = BestPartialDeducedArgs;     
     }
   }
 

       Converted, TemplateNameLoc, InsertPos /*, LateAttrs, StartingScope*/);
   if (!Decl)
     return true;
-
+  Template->AddSpecialization(Decl, InsertPos);
   if (AmbiguousPartialSpec) {
-    // Partial ordering did not produce a clear winner. Complain.
+    // Partial ordering did not produce a clear winner. 
     Decl->setInvalidDecl();
-    Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
-        << Decl;
-
-    // Print the matching partial specializations.
-    for (SmallVector<MatchResult, 4>::iterator P = Matched.begin(),
-                                               PEnd = Matched.end();
-         P != PEnd; ++P)
-      Diag(P->Partial->getLocation(), diag::note_partial_spec_match)
-          << getTemplateArgumentBindingsText(
-                 P->Partial->getTemplateParameters(), *P->Args);
     return true;
   }
 

   return None;
 }
 
+// Check whether we can expand the invented dummy template arguments (used
+// during analysis of explicit function specializations within a class scope
+// dependent context) into the remaining template parameters.
+
+template <class TemplateParameterDecl>
+bool canDummyPackExpansionExtendIntoRemainingTemplateParameters(
+    Sema &SemaRef, TemplateParameterDecl *TemplateParam,
+    TemplateParameterList *TemplateParams, TemplateDecl *Template,
+    const TemplateArgumentListInfo &TemplateArgs) {
+
+  struct DummyTemplateArgAdapter {
+    static DeclRefExpr *
+    getDummyPackArgument(NonTypeTemplateParmDecl *NTTP,
+                         const TemplateArgument &PotentiallyDummyTAPack,
+                         Sema &S) {
+      if (PotentiallyDummyTAPack.getKind() == TemplateArgument::Expression) {
+        SubstNonTypeTemplateParmExpr *DummyExpr =
+            dyn_cast<SubstNonTypeTemplateParmExpr>(
+                PotentiallyDummyTAPack.getAsExpr());
+        if (DummyExpr && isa<DeclRefExpr>(DummyExpr->getReplacement()) &&
+            S.InventedDummyNonTypeTemplateArguments.count(
+                cast<DeclRefExpr>(DummyExpr->getReplacement())))
+          return cast<DeclRefExpr>(DummyExpr->getReplacement());
+      }
+      return nullptr;
+    }
+
+    static bool isSameKindOfTemplateParameter(DeclRefExpr *DummyArg,
+                                              NamedDecl *NextParam,
+                                              Sema &SemaRef) {
+      return isa<NonTypeTemplateParmDecl>(NextParam) &&
+             SemaRef.Context.hasSameType(
+                 DummyArg->getType(),
+                 cast<NonTypeTemplateParmDecl>(NextParam)->getType());
+    }
+    static CXXRecordDecl *
+    getDummyPackArgument(TemplateTypeParmDecl *TTP,
+                         const TemplateArgument &PotentiallyDummyTAPack,
+                         Sema &) {
+      if (PotentiallyDummyTAPack.getKind() == TemplateArgument::Type) {
+        QualType UDummyTy = PotentiallyDummyTAPack.getAsType();
+        if (auto *RD = UDummyTy->getAsCXXRecordDecl()) {
+          if (RD->isImplicit() && RD->getName().startswith("$dummy-") &&
+              RD->getName().endswith("-pack"))
+            return RD;
+        }
+      }
+      return nullptr;
+    }
+    static bool isSameKindOfTemplateParameter(CXXRecordDecl *DummyArg,
+                                              NamedDecl *NextParam, Sema &) {
+      return isa<TemplateTypeParmDecl>(NextParam);
+    }
+    static TemplateDecl *
+    getDummyPackArgument(TemplateTemplateParmDecl *TTP,
+                         const TemplateArgument &PotentiallyDummyTAPack,
+                         Sema &) {
+      if (PotentiallyDummyTAPack.getKind() == TemplateArgument::Template) {
+        TemplateDecl *TD =
+            PotentiallyDummyTAPack.getAsTemplate().getAsTemplateDecl();
+        if (TD->isImplicit() && TD->getName().startswith("$dummy-") &&
+            TD->getName().endswith("-pack"))
+          return TD;
+      }
+      return nullptr;
+    }
+    static bool isSameKindOfTemplateParameter(TemplateDecl *DummyArg,
+                                              NamedDecl *NextParam,
+                                              Sema &SemaRef) {
+      if (TemplateTemplateParmDecl *NextTD =
+              dyn_cast<TemplateTemplateParmDecl>(NextParam)) {
+        // Make sure that the template parameter lists are compatible.
+        TemplateParameterList *DummyTPL = DummyArg->getTemplateParameters();
+        TemplateParameterList *NextTPL = NextTD->getTemplateParameters();
+        if (SemaRef.TemplateParameterListsAreEqual(
+                DummyTPL, NextTPL, /*Complain*/ false,
+                Sema::TPL_TemplateTemplateArgumentMatch, NextTD->getLocation()))
+          return true;
+      }
+      return false;
+    }
+  };
+
+  TemplateParameterList *Params = Template->getTemplateParameters();
+  const unsigned NumParams = Params->size();
+  const unsigned NumArgs = TemplateArgs.size();
+  // If we have runout of template arguments, check to see if we have a dummy
+  // pack expansion that we can expand into the remaining template arguments
+  bool CanExpandDummyPacksToFillRemainingTemplateParameters = false;
+  if (NumParams > NumArgs) {
+    TemplateArgumentLoc LastTA = TemplateArgs[NumArgs - 1];
+    const TemplateArgument &PotentiallyDummyTAPack = LastTA.getArgument();
+    if (auto *DummyArg = DummyTemplateArgAdapter::getDummyPackArgument(
+            TemplateParam, PotentiallyDummyTAPack, SemaRef)) {
+      CanExpandDummyPacksToFillRemainingTemplateParameters = true;
+      assert(Params->getParam(NumArgs) == TemplateParam);
+      for (unsigned I = NumArgs; I < NumParams; ++I) {
+        if (!DummyTemplateArgAdapter::isSameKindOfTemplateParameter(
+                DummyArg, Params->getParam(I), SemaRef)) {
+          CanExpandDummyPacksToFillRemainingTemplateParameters = false;
+          break;
+        }
+      }
+    }
+  }
+  return CanExpandDummyPacksToFillRemainingTemplateParameters;
+}
 /// \brief Check that the given template argument list is well-formed
 /// for specializing the given template.
 bool Sema::CheckTemplateArgumentList(TemplateDecl *Template,

     // (when the template parameter was part of a nested template) into
     // the default argument.
     if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) {
-      if (!TTP->hasDefaultArgument())
-        return diagnoseArityMismatch(*this, Template, TemplateLoc, 
+      if (!TTP->hasDefaultArgument()) {
+        // Check if we have a dummy-pack that we can extend-by-any as needed.
+        // dummy-packs are synthesized during checking explicit specializations
+        // of member template functions within a dependent class (i.e. class
+        // template)
+        if (canDummyPackExpansionExtendIntoRemainingTemplateParameters(
+                *this, TTP, Params, Template, TemplateArgs))
+          return false;
+        return diagnoseArityMismatch(*this, Template, TemplateLoc,
                                      TemplateArgs);
+      }
 
       TypeSourceInfo *ArgType = SubstDefaultTemplateArgument(*this,
                                                              Template,

                                 ArgType);
     } else if (NonTypeTemplateParmDecl *NTTP
                  = dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
-      if (!NTTP->hasDefaultArgument())
+      if (!NTTP->hasDefaultArgument()) {
+        // Check if we have a dummy-pack that we can extend-by-any as needed.
+        // dummy-packs are synthesized during checking explicit specializations
+        // of member template functions within a dependent class (i.e. class
+        // template)
+        if (canDummyPackExpansionExtendIntoRemainingTemplateParameters(
+                *this, NTTP, Params, Template, TemplateArgs))
+          return false;
         return diagnoseArityMismatch(*this, Template, TemplateLoc, 
                                      TemplateArgs);
+      }
 
       ExprResult E = SubstDefaultTemplateArgument(*this, Template,
                                                               TemplateLoc,

       TemplateTemplateParmDecl *TempParm
         = cast<TemplateTemplateParmDecl>(*Param);
 
-      if (!TempParm->hasDefaultArgument())
+      if (!TempParm->hasDefaultArgument()) { 
+        // Check if we have a dummy-pack that we can extend-by-any.
+        // dummy-packs are synthesized during checking explicit specializations
+        // of member template functions within a dependent class (i.e. class
+        // template)
+        if (canDummyPackExpansionExtendIntoRemainingTemplateParameters(
+                *this, TempParm, Params, Template, TemplateArgs))
+          return false;
         return diagnoseArityMismatch(*this, Template, TemplateLoc, 
                                      TemplateArgs);
+      }
 
       NestedNameSpecifierLoc QualifierLoc;
       TemplateName Name = SubstDefaultTemplateArgument(*this, Template,

   }
 
   if (S.CurContext->isRecord() && !IsPartialSpecialization) {
-    if (S.getLangOpts().MicrosoftExt) {
+    // Explicit specializations are allowed in class scope post DR727
+    // that was accepted by EWG as a DR post C++11/14.
+    if (S.getLangOpts().MicrosoftExt || S.getLangOpts().CPlusPlus1y) {
       // Do not warn for class scope explicit specialization during
       // instantiation, warning was already emitted during pattern
       // semantic analysis.
-      if (!S.ActiveTemplateInstantiations.size())
-        S.Diag(Loc, diag::ext_function_specialization_in_class)
-          << Specialized;
+      if (!S.ActiveTemplateInstantiations.size() &&
+          !S.getLangOpts().CPlusPlus1y)
+        S.Diag(Loc, diag::ext_function_specialization_in_class) << Specialized;
     } else {
       S.Diag(Loc, diag::err_template_spec_decl_class_scope)
         << Specialized;

 
   return false;
 }
-
-DeclResult
-Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
-                                       TagUseKind TUK,
-                                       SourceLocation KWLoc,
-                                       SourceLocation ModulePrivateLoc,
-                                       TemplateIdAnnotation &TemplateId,
-                                       AttributeList *Attr,
-                               MultiTemplateParamsArg TemplateParameterLists) {
+DeclResult Sema::ActOnClassTemplateSpecialization(
+    Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,
+    SourceLocation ModulePrivateLoc, TemplateIdAnnotation &TemplateId,
+    AttributeList *Attr, MultiTemplateParamsArg TemplateParameterLists) {
   assert(TUK != TUK_Reference && "References are not specializations");
 
   CXXScopeSpec &SS = TemplateId.SS;

 
     if (!PrevPartial)
       ClassTemplate->AddPartialSpecialization(Partial, InsertPos);
+   
     Specialization = Partial;
-
+    const bool HasEmptyTemplateParameterLists = ([](
+        const ArrayRef<TemplateParameterList *> TemplateParameterLists) {
+      for (const auto *CurTPL : TemplateParameterLists)
+        if (!CurTPL->size())
+          return true;
+      return false;
+    })(TemplateParameterLists);
     // If we are providing an explicit specialization of a member class
     // template specialization, make a note of that.
-    if (PrevPartial && PrevPartial->getInstantiatedFromMember())
-      PrevPartial->setMemberSpecialization();
+    if (HasEmptyTemplateParameterLists) 
+      (PrevPartial ? PrevPartial : Partial)->setMemberSpecialization();
   
     // Check that all of the template parameters of the class template
     // partial specialization are deducible from the template
     // arguments. If not, this class template partial specialization

         }
       }
     }
+    // Check to see if ClassTemplateDecl has any instantiations (make sure
+    // they are implicitly instantiated and not explicit specializations!) that
+    // would use this partial specialization, and if so, this is an error!
+    if (!PrevDecl) {
+      ClassTemplateSpecializationDecl *const
+      InstThatWouldHaveUsedPartialSpec = ([](
+          ClassTemplateDecl *ClassTemplate,
+          ClassTemplatePartialSpecializationDecl *Partial,
+          SourceLocation PointOfInstantiation, Sema &SemaRef) {
+        for (ClassTemplateSpecializationDecl *Spec :
+             ClassTemplate->specializations()) {
+          if (Spec->getTemplateSpecializationKind() ==
+              TSK_ExplicitSpecialization)
+            continue;
+          // Unlike for Variable Templates - unless the definition has been
+          // generated, we can declare a partial specialization after a
+          // 'mention' that has not required an instantiation.
+          if (!Spec->isCompleteDefinition())
+            continue;
+          const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
+          TemplateDeductionInfo Info(PointOfInstantiation);
+          if (Sema::TemplateDeductionResult Result =
+                  SemaRef.DeduceTemplateArguments(Partial, TemplateArgs,
+                                                  Info)) {
+            /* we could not have used this partial specialization so ignore...*/
+          } else {
+            return Spec;
+          }
+        }
+        return static_cast<ClassTemplateSpecializationDecl *>(nullptr);
+      }(ClassTemplate, Partial, TemplateId.TemplateNameLoc, *this));
+
+      if (InstThatWouldHaveUsedPartialSpec) {
+        SourceRange Range(TemplateNameLoc, RAngleLoc);
+        Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
+            << Name << Range;
+
+        Diag(InstThatWouldHaveUsedPartialSpec->getPointOfInstantiation(),
+             diag::note_instantiation_required_here)
+            << 0;
+      }
+    }
   } else {
     // Create a new class template specialization declaration node for
     // this explicit specialization or friend declaration.

   return false;
 }
 
+namespace {
+
+// Used to create a key for the invented type that is used to determine
+// whether an explicit specialization of a member template function
+// within a dependent context (class template) is well-formed.
+struct InventedTemplateArgKey {
+  unsigned Depth;
+  unsigned Index;
+  std::string Postfix;
+  InventedTemplateArgKey() : Depth(0), Index(0) {}
+  InventedTemplateArgKey(unsigned D, unsigned I, const std::string &P)
+      : Depth(D), Index(I), Postfix(P) {}
+
+  bool operator<(const InventedTemplateArgKey &Rhs) const {
+    const InventedTemplateArgKey &Lhs = *this;
+    // First sort based on depth, then level, then prefix.
+    if (Lhs.Depth < Rhs.Depth)
+      return true;
+    // Depths are equal so use level...
+    if (Lhs.Depth == Rhs.Depth) {
+      if (Lhs.Index < Rhs.Index)
+        return true;
+      // FIXME: I think we can drop the comparison dependence on Postfix.
+      if (Lhs.Index == Rhs.Index)
+        return Lhs.Postfix < Rhs.Postfix;
+    }
+    return false;
+  }
+};
+
+// Invent a type uniqued to the depth and index of the template parameter we
+// will be substituting into.
+inline QualType getInventedDependentType(Sema &SemaRef,
+                                         DeclContext *DependentDC,
+                                         SourceLocation PointOfInstantiation,
+                                         unsigned Depth, unsigned Index,
+                                         std::string Postfix = "") {
+
+  InventedTemplateArgKey MKey(Depth, Index, Postfix);
+  // FIXME: Move this into ASTContext & CXXRecordDecl (i.e
+  // CreateUniqueRecordType(D, L, P) etc. and add isSyntheticUniqueDependentType
+  // or some such named function into CXXRecorDecl so that FindInstantiatedDecl
+  // can query this property directly.
+  static std::map<InventedTemplateArgKey, const CXXRecordDecl *>
+  InventedRecordDeclMap;
+  const CXXRecordDecl *InventedRD = nullptr;
+  // Create the name and record type and add to the map.
+  if (!(InventedRD = InventedRecordDeclMap[MKey])) {
+    assert(DependentDC->isDependentContext());
+    // Create a name for the invented unique type.
+    std::string InventedDummyTypeName = "$dummy-";
+    llvm::raw_string_ostream ss(InventedDummyTypeName);
+    ss << Depth;
+    ss << "-" << Index;
+    if (Postfix.length())
+      ss << "-" << Postfix;
+    ss.flush();
+
+    IdentifierInfo &InventedTypeII =
+        SemaRef.Context.Idents.get(InventedDummyTypeName.c_str());
+    auto *RD = CXXRecordDecl::Create(SemaRef.Context, TTK_Class, DependentDC,
+                                     PointOfInstantiation, PointOfInstantiation,
+                                     &InventedTypeII, nullptr);
+    RD->setImplicit(true);
+    InventedRD = RD;
+    InventedRecordDeclMap[MKey] = InventedRD;
+  }
+  return SemaRef.Context.getRecordType(InventedRD);
+}
+inline DeclRefExpr *
+getInventedDependentExpr(Sema &SemaRef, DeclContext *DependentDC,
+                         SourceLocation PointOfInstantiation,
+                         NonTypeTemplateParmDecl *NonTypeParam) {
+
+  const bool IsPack = NonTypeParam->isParameterPack();
+  InventedTemplateArgKey MKey(NonTypeParam->getDepth(),
+                              NonTypeParam->getIndex(), IsPack ? "pack" : "");
+
+  static std::map<InventedTemplateArgKey, DeclRefExpr *> InventedExprMap;
+  if (DeclRefExpr *DRE = InventedExprMap[MKey])
+    return DRE;
+
+  if (IsPack) {
+    // If this is a pack, create an invented non-pack non-type-parm so that
+    // it doesn't force our DRE to contain an unexpanded pack when
+    // this dependent expression is substituted into packs.
+    NonTypeParam = NonTypeTemplateParmDecl::Create(
+        SemaRef.Context, NonTypeParam->getDeclContext(),
+        NonTypeParam->getLocStart(), NonTypeParam->getInnerLocStart(),
+        NonTypeParam->getDepth(), NonTypeParam->getIndex(),
+        NonTypeParam->getIdentifier(), NonTypeParam->getType(),
+        /*IsPack*/ false, NonTypeParam->getTypeSourceInfo());
+  }
+  DeclRefExpr *DRE = DeclRefExpr::Create(
+      SemaRef.Context, NestedNameSpecifierLoc(), SourceLocation(), NonTypeParam,
+      false, DeclarationNameInfo(DeclarationName(NonTypeParam->getIdentifier()),
+                                 NonTypeParam->getLocation()),
+      NonTypeParam->getType(), VK_RValue);
+  SemaRef.InventedDummyNonTypeTemplateArguments.insert(DRE);
+  DRE->setValueDependent(true);
+  DRE->setTypeDependent(true);
+  DRE->setInstantiationDependent(true);
+  InventedExprMap[MKey] = DRE;
+  return DRE;
+}
+
+inline ClassTemplateDecl *
+getInventedDependentTemplate(Sema &SemaRef, DeclContext *DependentDC,
+                             SourceLocation PointOfInstantiation,
+                             const TemplateTemplateParmDecl *TemplParam) {
+  const bool IsPack = TemplParam->isParameterPack();
+  QualType InventedTy = getInventedDependentType(
+      SemaRef, DependentDC, PointOfInstantiation, TemplParam->getDepth(),
+      TemplParam->getIndex(), IsPack ? "-pack" : "");
+  const CXXRecordDecl *InventedClass = InventedTy->getAsCXXRecordDecl();
+  static std::map<const CXXRecordDecl *, ClassTemplateDecl *>
+  InventedTemplateMap;
+  if (ClassTemplateDecl *InventedTempl = InventedTemplateMap[InventedClass])
+    return InventedTempl;
+
+  // Create a name for the invented unique template.
+  std::string InventedDummyTemplName = "$dummy-";
+  llvm::raw_string_ostream ss(InventedDummyTemplName);
+  ss << TemplParam->getDepth();
+  ss << "-" << TemplParam->getIndex() << "-template" << (IsPack ? "-pack" : "");
+  ss.flush();
+
+  IdentifierInfo &InventedTemplII =
+      SemaRef.Context.Idents.get(InventedDummyTemplName.c_str());
+  DeclarationName UniqueTemplName(&InventedTemplII);
+  ClassTemplateDecl *InventedTempl = ClassTemplateDecl::Create(
+      SemaRef.Context, DependentDC, PointOfInstantiation, UniqueTemplName,
+      TemplParam->getTemplateParameters(),
+      const_cast<CXXRecordDecl *>(InventedClass), nullptr);
+  InventedTempl->setImplicit(true);
+  InventedTemplateMap[InventedClass] = InventedTempl;
+  return InventedTempl;
+}
+
+// The type synthesized for a pack needs to be stored in a TemplateArgument
+// that needs to have a life time that extends beyond the call of the
+// calling function.
+// FIXME: We could return a unique_ptr that can be held as long as the vector.
+const TemplateArgument &getInventedTypeAsTemplateArgument(QualType InventedTy) {
+  static std::map<CXXRecordDecl *, TemplateArgument> InventedTArgMap;
+  CXXRecordDecl *Key = InventedTy->getAsCXXRecordDecl();
+  assert(Key);
+  TemplateArgument &Val = InventedTArgMap[Key];
+  if (Val.isNull())
+    Val = TemplateArgument(InventedTy);
+  return Val;
+}
+
+// The template synthesized for a pack needs to be stored in a TemplateArgument
+// that needs to have a life time that extends beyond the call of the
+// calling function.
+// FIXME: We could return a unique_ptr that can be held as long as the vector.
+const TemplateArgument &
+getInventedTemplateAsTemplateArgument(ClassTemplateDecl *InventedTempl) {
+  static std::map<ClassTemplateDecl *, TemplateArgument> InventedTArgMap;
+  TemplateArgument &Val = InventedTArgMap[InventedTempl];
+  if (Val.isNull())
+    Val = TemplateArgument(TemplateName(InventedTempl));
+  return Val;
+}
+
+const TemplateArgument &
+getInventedExprAsTemplateArgument(DeclRefExpr *InventedDRE) {
+  static std::map<DeclRefExpr *, TemplateArgument> InventedTArgMap;
+  TemplateArgument &Val = InventedTArgMap[InventedDRE];
+  if (Val.isNull())
+    Val = TemplateArgument(InventedDRE);
+  return Val;
+}
+}
+
+namespace {
+SmallVector<TemplateArgument, 4>
+getInventedTemplateArguments(Sema &SemaRef,
+                             TemplateDecl *TD,
+                             SourceLocation PointOfInstantiation) {
+  SmallVector<TemplateArgument, 4> TArgs;
+  TemplateParameterList *CurTPL = TD->getTemplateParameters();
+  
+  static DeclContext *DependentDC = ([&] {
+    // Create a dummy dependent decl context that will contain all the dummy
+    // template arguments we invent.
+    const char *InventedDummyDCPatternName = "$dummy-declcontext-pattern";
+    const char *InventedDummyDCTemplName = "$dummy-declcontext-template";
+
+    IdentifierInfo &InventedTypeII =
+        SemaRef.Context.Idents.get(InventedDummyDCPatternName);
+    auto *InventedRD = CXXRecordDecl::Create(
+        SemaRef.Context, TTK_Class, SemaRef.Context.getTranslationUnitDecl(),
+        PointOfInstantiation, PointOfInstantiation, &InventedTypeII, nullptr);
+
+    DeclarationName UniqueTemplName(
+        &SemaRef.Context.Idents.get(InventedDummyDCTemplName));
+    auto *InventedTempl = ClassTemplateDecl::Create(
+        SemaRef.Context, SemaRef.Context.getTranslationUnitDecl(),
+        PointOfInstantiation, UniqueTemplName,
+        TemplateParameterList::Create(SemaRef.Context, SourceLocation(),
+                                      SourceLocation(), nullptr, 0,
+                                      SourceLocation()),
+        const_cast<CXXRecordDecl *>(InventedRD), nullptr);
+
+    InventedRD->setDescribedClassTemplate(InventedTempl);
+    InventedRD->setImplicit();
+    InventedTempl->setImplicit();
+    return InventedRD;
+  })();
+
+  for (NamedDecl *ND : CurTPL->asArray()) {
+    if (TemplateTypeParmDecl *TypeParam = dyn_cast<TemplateTypeParmDecl>(ND)) {
+      // Generate a unique dependent type to substitute for this template param.
+      const bool IsPack = TypeParam->isParameterPack();
+      QualType InventedTy = getInventedDependentType(
+          SemaRef, DependentDC, PointOfInstantiation, TypeParam->getDepth(),
+          TypeParam->getIndex(), IsPack ? "pack" : "");
+      const TemplateArgument &TArg = getInventedTypeAsTemplateArgument(InventedTy);
+      TArgs.push_back(IsPack ? TemplateArgument(&TArg, 1) : TArg);
+    } else if (NonTypeTemplateParmDecl *NonTypeParam =
+                   dyn_cast<NonTypeTemplateParmDecl>(ND)) {
+      const bool IsPack = NonTypeParam->isParameterPack();
+      DeclRefExpr *InventedDRE = getInventedDependentExpr(SemaRef, DependentDC, PointOfInstantiation, NonTypeParam);
+      const TemplateArgument &TArg = getInventedExprAsTemplateArgument(InventedDRE);
+      TArgs.push_back(IsPack ? TemplateArgument(&TArg, 1) : TArg);
+
+    } else if (TemplateTemplateParmDecl *TemplParam =
+                   dyn_cast<TemplateTemplateParmDecl>(ND)) {
+      const TemplateArgument &InventedTemplArg =
+          getInventedTemplateAsTemplateArgument(getInventedDependentTemplate(
+              SemaRef, DependentDC, PointOfInstantiation, TemplParam));
+      TArgs.push_back(TemplParam->isParameterPack()
+                          ? TemplateArgument(&InventedTemplArg, 1)
+                          : InventedTemplArg);
+    }
+  }
+  return TArgs;
+}
+} // end anynoymous ns
+
+/// \brief Perform semantic analysis for the given dependent member function
+/// explicit template specialization.
+///
+/// For e.g.:
+///
+/// \code
+///   template \<class T> class A {
+///     template \<class U> U* foo(U*, T*) { return 0; };
+///     template<> char* foo(int*, float*, char*); <-- this should be an error
+///   };
+/// \endcode
+///
+/// The potential analysis that can be done here:
+///  - try and deduce only the template parameters at that level
+///  - all other parameters should match exactly
+///  - we can not just rely on the number of parameters - since we can have variadic templates
+///    
+
+bool Sema::checkDependentClassScopeFunctionExplicitSpecialization(
+    FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs,
+    LookupResult &Previous) {
+  // The set of function template specializations that could match this
+  // explicit function template specialization.
+  UnresolvedSet<8> Candidates;
+  TemplateSpecCandidateSet FailedCandidates(FD->getLocation());
+  // Retrieve the actual template from the the dummy specialization.
+  std::map<FunctionDecl *, FunctionTemplateDecl *> MapDummySpecToRealTemplate;
+  // A pointer to the dummy explicit template args.
+  TemplateArgumentListInfo *DummyExplicitTemplateArgs = nullptr;
+  // A temporary object that DummyExplicitTemplateArgs will point to if needed.
+  TemplateArgumentListInfo DummyExplicitTemplateArgsOnStack;
+
+  // We need to store each template arg vector so that we can pass
+  // a reference to each vector to OuterTemplateArgs.
+  SmallVector<SmallVector<TemplateArgument, 4>, 4> TemplateArgsVectors;
+  MultiLevelTemplateArgumentList OuterTemplateArgs;
+  // Climb through all dependent contexts that are templates and
+  // invent arguments for each of their template parameter lists.
+  DeclContext *ParentDC = FD->getDeclContext();
+  while (ParentDC && ParentDC->isDependentContext()) {
+    assert([&] {
+      if (!isa<CXXRecordDecl>(ParentDC))
+        if (Decl *D = dyn_cast<Decl>(ParentDC))
+          D->dump();
+      assert(isa<CXXRecordDecl>(ParentDC) &&
+             "A dependent decl context must be a CXXRecordDecl!");
+      return true;
+    }());
+    CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(ParentDC);
+    if (TemplateDecl *TD = RD->getDescribedClassTemplate()) {
+      TemplateArgsVectors.push_back(getInventedTemplateArguments(
+          *this, TD, /*PointOfInstantiation*/FD->getLocStart()));
+      OuterTemplateArgs.addOuterTemplateArguments(TemplateArgsVectors.back());
+    }
+    ParentDC = ParentDC->getParent();
+  }
+
+  DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext();
+  for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
+         I != E; ++I) {
+    NamedDecl *Ovl = (*I)->getUnderlyingDecl();
+    if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Ovl)) {
+      // Only consider templates found within the same semantic lookup scope as
+      // FD.
+      if (!FDLookupContext->InEnclosingNamespaceSetOf(
+                                Ovl->getDeclContext()->getRedeclContext()))
+        continue;
+
+      // When matching a constexpr member function template specialization
+      // against the primary template, we don't yet know whether the
+      // specialization has an implicit 'const' (because we don't know whether
+      // it will be a static member function until we know which template it
+      // specializes), so adjust it now assuming it specializes this template.
+      QualType FT = FD->getType();
+      if (FD->isConstexpr()) {
+        CXXMethodDecl *OldMD =
+          dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
+        if (OldMD && OldMD->isConst()) {
+          const FunctionProtoType *FPT = FT->castAs<FunctionProtoType>();
+          FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
+          EPI.TypeQuals |= Qualifiers::Const;
+          FT = Context.getFunctionType(FPT->getReturnType(),
+                                       FPT->getParamTypes(), EPI);
+        }
+      }
+
+      // C++ [temp.expl.spec]p11:
+      //   A trailing template-argument can be left unspecified in the
+      //   template-id naming an explicit function template specialization
+      //   provided it can be deduced from the function argument type.
+      // Perform template argument deduction to determine whether we may be
+      // specializing this template.
+      // FIXME: It is somewhat wasteful to build
+      TemplateDeductionInfo Info(FailedCandidates.getLocation());
+      FunctionDecl *Specialization = 0;
+      CXXMethodDecl *DummyFD = nullptr;
+
+      auto *DummyFTD = ([&DummyFD, &DummyExplicitTemplateArgs,
+                         &DummyExplicitTemplateArgsOnStack,
+                         ExplicitTemplateArgs, &OuterTemplateArgs](
+          Sema &SemaRef, SourceLocation PointOfInstantiation,
+          FunctionTemplateDecl *FTD, CXXMethodDecl *ExplicitFD) {
+
+        Sema::InstantiatingTemplate Inst(SemaRef, PointOfInstantiation, FTD);
+        // If we have exceeded the maximum recursion instantiation depth,
+        // return
+        // null.
+        // FIXME: What diagnostic should we emit here?
+        if (Inst.isInvalid())
+          return static_cast<FunctionTemplateDecl *>(FTD);
+
+        // Enter the DeclContext that contains the partial spec we will be
+        // substituting into ...
+        // We don't use PushDeclContext because we don't have a scope.
+        Sema::ContextRAII SavedContext(SemaRef, FTD->getDeclContext());
+
+        EnterExpressionEvaluationContext EvalContext(SemaRef,
+                                                     Sema::Unevaluated);
+
+        Sema::SFINAETrap IntroduceSFINAE(SemaRef, true);
+        if (ExplicitTemplateArgs && !DummyExplicitTemplateArgs) {
+          // Substitue into the explicitly specified template arguments.
+          DummyExplicitTemplateArgs = &DummyExplicitTemplateArgsOnStack;
+          DummyExplicitTemplateArgs->setLAngleLoc(
+              ExplicitTemplateArgs->getLAngleLoc());
+          DummyExplicitTemplateArgs->setRAngleLoc(
+              ExplicitTemplateArgs->getRAngleLoc());
+          if (SemaRef.Subst(ExplicitTemplateArgs->getArgumentArray(),
+                            ExplicitTemplateArgs->size(),
+                            DummyExplicitTemplateArgsOnStack,
+                            OuterTemplateArgs))
+            return static_cast<FunctionTemplateDecl *>(nullptr);
+        }
+        TemplateDeclInstantiator DeclInstantiator(
+            SemaRef, FTD->getDeclContext(), OuterTemplateArgs);
+
+        auto *NewFTD = cast_or_null<FunctionTemplateDecl>(
+            DeclInstantiator.VisitFunctionTemplateDecl(FTD, true));
+        // Set access temporarily for now - we will update access
+        // once the parent template has been selected.
+        ExplicitFD->setAccess(FTD->getAccess());
+        DummyFD = cast_or_null<CXXMethodDecl>(
+            DeclInstantiator.VisitCXXMethodDecl(ExplicitFD, nullptr, true));
+        return NewFTD;
+      }(*this, FD->getLocStart(),
+        cast<FunctionTemplateDecl>(FunTmpl->getFirstDecl()),
+        cast<CXXMethodDecl>(FD)));
+      if (!DummyFTD || !DummyFD)
+        continue;
+
+      if (TemplateDeductionResult TDK = DeduceTemplateArguments(
+              DummyFTD, DummyExplicitTemplateArgs, DummyFD->getType(),
+              Specialization, Info)) {
+        // Template argument deduction failed; record why it failed, so
+        // that we can provide nifty diagnostics.
+        FailedCandidates.addCandidate()
+            .set(FunTmpl->getTemplatedDecl(),
+                 MakeDeductionFailureInfo(Context, TDK, Info));
+        (void)TDK;
+        continue;
+      }
+      MapDummySpecToRealTemplate[Specialization] = FunTmpl;
+      // Record this candidate.
+      Candidates.addDecl(Specialization, I.getAccess());
+    }
+  }
+
+  // Find the most specialized function template.
+  UnresolvedSetIterator Result = getMostSpecialized(
+      Candidates.begin(), Candidates.end(), FailedCandidates,
+      FD->getLocation(),
+      PDiag(diag::err_function_template_spec_no_match) << FD->getDeclName(),
+      PDiag(diag::err_function_template_spec_ambiguous)
+          << FD->getDeclName() << (ExplicitTemplateArgs != 0),
+      PDiag(diag::note_function_template_spec_matched));
+
+  if (Result == Candidates.end()) {
+    FD->setInvalidDecl();
+    return true;
+  }
+
+  FunctionDecl *DummySpecialization = cast<FunctionDecl>(*Result);
+  FunctionTemplateDecl *RealTemplate =
+      MapDummySpecToRealTemplate[DummySpecialization];
+
+  FunctionTemplateSpecializationInfo *DummySpecInfo =
+      DummySpecialization->getTemplateSpecializationInfo();
+  void *InsertPos = 0;
+
+  // FIXME:
+  // We should transform all references to dummy-types within the 
+  // deduced template arguments back into their corresponding template types 
+  // - so that if the explicit specialization is specialized using outer 
+  // template parameters - we refer to them and not to the dummy-types.
+  //   - the way to do this is to use the type-transformer and where
+  //     ever we find a dummy-type or dummy-expr or dummy-template
+  //     based on its depth and index we replace it with its outer 
+  //     corresponding template parameter.
+  //     - look at SemaTemplateDeduction.cpp::SubstituteAutoTransform
+  //       to replace a dummy type with its template parameter type 
+  //     - look at Type.cpp::GetContainedAutoVisitor to check if a dummy
+  //       type is present within a template-argument.
+  //     [Note: that above visitors will need to be adapted and must handle
+  //       dummy-nontypes and dummy-templates]
+  //     We should maintain a mapping from dummy-exprs to original exprs
+  //     dummy-types to original template parameter types & dummy-types to
+  //     original tempalte type parameters - so that we can substitute them
+  //     back in.
+  //  Currently within the deduced arguments is the only place where references
+  //  to these dummy arguments persist.  The only purpose they serve is to 
+  //  early detect redefinitions.
+  if (FunctionDecl *PrevSpec = RealTemplate->findSpecialization(
+          DummySpecInfo->TemplateArguments->data(),
+          DummySpecInfo->TemplateArguments->size(), InsertPos)) {
+    Previous.clear();
+    Previous.addDecl(PrevSpec);
+  } else {
+    FD->setFunctionTemplateSpecialization(
+        RealTemplate, DummySpecInfo->TemplateArguments, InsertPos,
+        TSK_ExplicitSpecialization, ExplicitTemplateArgs, FD->getLocation());
+  }
+  return false;
+}
+
 /// \brief Perform semantic analysis for the given function template
 /// specialization.
 ///

       // FIXME: It is somewhat wasteful to build
       TemplateDeductionInfo Info(FailedCandidates.getLocation());
       FunctionDecl *Specialization = 0;
+      struct MethodSpecBeingDeclaredRAII {
+        Sema &SemaRef;
+        MethodSpecBeingDeclaredRAII(CXXMethodDecl *PatternOfMethodBeingDeclared,
+                                    Sema &S)
+            : SemaRef(S) {
+          SemaRef.PatternOfMethodSpecializationBeingDeclared.push_back(
+              PatternOfMethodBeingDeclared);
+        }
+        ~MethodSpecBeingDeclaredRAII() {
+          SemaRef.PatternOfMethodSpecializationBeingDeclared.pop_back();
+        }
+      };
+      std::unique_ptr<MethodSpecBeingDeclaredRAII> MethodSpecBeingDeclaredRAIIObj;
+      if (isa<CXXMethodDecl>(FD) &&
+          isa<CXXMethodDecl>(FunTmpl->getTemplatedDecl()))
+        MethodSpecBeingDeclaredRAIIObj.reset(new MethodSpecBeingDeclaredRAII(
+            cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl()), *this));
+
       if (TemplateDeductionResult TDK = DeduceTemplateArguments(
               cast<FunctionTemplateDecl>(FunTmpl->getFirstDecl()),
               ExplicitTemplateArgs, FT, Specialization, Info)) {

lib/Sema/SemaTemplateDeduction.cpp

 /// \brief If the given expression is of a form that permits the deduction
 /// of a non-type template parameter, return the declaration of that
 /// non-type template parameter.
-static NonTypeTemplateParmDecl *getDeducedParameterFromExpr(Expr *E) {
+static NonTypeTemplateParmDecl *getDeducedParameterFromExpr(Expr *E, Sema &S) {
   // If we are within an alias template, the expression may have undergone
   // any number of parameter substitutions already.
   while (1) {

       break;
   }
 
-  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
+  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
+    if (S.InventedDummyNonTypeTemplateArguments.count(DRE))
+      return nullptr;
     return dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
-
+  }
   return 0;
 }
 

   return Sema::TDK_Success;
 }
 
+
 /// \brief Deduce the value of the given non-type template parameter
 /// from the given type- or value-dependent expression.
 ///

          "Cannot deduce non-type template argument with depth > 0");
   assert((Value->isTypeDependent() || Value->isValueDependent()) &&
          "Expression template argument must be type- or value-dependent.");
-
   DeducedTemplateArgument NewDeduced(Value);
   DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
                                                      Deduced[NTTP->getIndex()],

 
       // Determine the array bound is something we can deduce.
       NonTypeTemplateParmDecl *NTTP
-        = getDeducedParameterFromExpr(DependentArrayParm->getSizeExpr());
+        = getDeducedParameterFromExpr(DependentArrayParm->getSizeExpr(), S);
       if (!NTTP)
         return Sema::TDK_Success;
 

         
         // Perform deduction on the vector size, if we can.
         NonTypeTemplateParmDecl *NTTP
-          = getDeducedParameterFromExpr(VectorParam->getSizeExpr());
+          = getDeducedParameterFromExpr(VectorParam->getSizeExpr(), S);
         if (!NTTP)
           return Sema::TDK_Success;
 

         
         // Perform deduction on the vector size, if we can.
         NonTypeTemplateParmDecl *NTTP
-          = getDeducedParameterFromExpr(VectorParam->getSizeExpr());
+          = getDeducedParameterFromExpr(VectorParam->getSizeExpr(), S);
         if (!NTTP)
           return Sema::TDK_Success;
         

   llvm_unreachable("Invalid Type Class!");
 }
 
+namespace clang {
+Sema::TemplateDeductionResult
+DeduceTemplateArgumentsByTypeMatchForExplicitSpecializations(
+    Sema &S, FunctionTemplateDecl *PrimaryTemplate,
+    CXXMethodDecl *SubstitutedExplicitSpecialization,
+    TemplateArgumentListInfo *SubstitutedExplicitTemplateArgs,
+    TemplateDeductionInfo &Info,
+    SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
+  TemplateParameterList *TemplateParams =
+      PrimaryTemplate->getTemplateParameters();
+  QualType PrimaryTemplateType = PrimaryTemplate->getTemplatedDecl()->getType();
+  QualType ExplicitSpecType = SubstitutedExplicitSpecialization->getType();
+  ExplicitSpecType =
+      S.adjustCCAndNoReturn(ExplicitSpecType, PrimaryTemplateType);
+  if (SubstitutedExplicitTemplateArgs) {
+    LocalInstantiationScope NewInstScope(S, false);
+    SmallVector<QualType, 4> ParamTypes;
+    if (Sema::TemplateDeductionResult Result =
+            S.SubstituteExplicitTemplateArguments(
+                PrimaryTemplate, *SubstitutedExplicitTemplateArgs, Deduced,
+                ParamTypes, &PrimaryTemplateType, Info))
+      return Result;
+  }
+
+  Deduced.resize(TemplateParams->size());
+  return DeduceTemplateArgumentsByTypeMatch(
+      S, TemplateParams, PrimaryTemplateType, ExplicitSpecType, Info, Deduced,
+      TDF_TopLevelParameterTypeList);
+}
+}
+
 static Sema::TemplateDeductionResult
 DeduceTemplateArguments(Sema &S,
                         TemplateParameterList *TemplateParams,

 
   case TemplateArgument::Expression: {
     if (NonTypeTemplateParmDecl *NTTP
-          = getDeducedParameterFromExpr(Param.getAsExpr())) {
+          = getDeducedParameterFromExpr(Param.getAsExpr(), S)) {
       if (Arg.getKind() == TemplateArgument::Integral)
         return DeduceNonTypeTemplateArgument(S, NTTP,
                                              Arg.getAsIntegral(),

   if (!Specialization || Specialization->isInvalidDecl())
     return TDK_SubstitutionFailure;
 
-  assert(Specialization->getPrimaryTemplate()->getCanonicalDecl() ==
-         FunctionTemplate->getCanonicalDecl());
+  // FIXME: If a specialization is generated from a dependent scope explicit
+  // specialization of a member template - check to make sure its ancestor 
+  // template - via getInstantiationOfMemberFunction - returns a specialization 
+  // of the member template which this template is instantiated from.
 
   // If the template argument list is owned by the function template
   // specialization, release it.

   if (!ArgFunctionType.isNull()) {
     unsigned TDF = TDF_TopLevelParameterTypeList;
     if (InOverloadResolution) TDF |= TDF_InOverloadResolution;
+
+
+
+
     // Deduce template arguments from the function type.
     if (TemplateDeductionResult Result
           = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,

   return SpecEnd;
 }
 
-/// \brief Returns the more specialized class template partial specialization
-/// according to the rules of partial ordering of class template partial
-/// specializations (C++ [temp.class.order]).
-///
-/// \param PS1 the first class template partial specialization
-///
-/// \param PS2 the second class template partial specialization
-///
-/// \returns the more specialized class template partial specialization. If
-/// neither partial specialization is more specialized, returns NULL.
-ClassTemplatePartialSpecializationDecl *
-Sema::getMoreSpecializedPartialSpecialization(
-                                  ClassTemplatePartialSpecializationDecl *PS1,
-                                  ClassTemplatePartialSpecializationDecl *PS2,
-                                              SourceLocation Loc) {
+namespace {
+  struct GetMoreSpecializedPartialSpecializationImpl;
+}
+// Implementation details of getMoreSpecializedPartialSpecializationImpl
+struct ::GetMoreSpecializedPartialSpecializationImpl{
+  
+  static QualType getTypeOfPartialSpecialization(
+      ClassTemplatePartialSpecializationDecl *PS) {
+    return PS->getInjectedSpecializationType();
+  }
+  
+  static QualType
+  getTypeOfPartialSpecialization(VarTemplatePartialSpecializationDecl *PS) {
+    TemplateName Name(PS->getSpecializedTemplate());
+    ASTContext &Context = PS->getASTContext();
+    TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
+    return Context.getTemplateSpecializationType(CanonTemplate,
+                                                 PS->getTemplateArgs().data(),
+                                                 PS->getTemplateArgs().size());
+  
+  }
+  
+
+};
+
+template <class PartialSpecializationDecl>
+PartialSpecializationDecl *
+getMoreSpecializedPartialSpecializationImpl(PartialSpecializationDecl *PS1,
+                                        PartialSpecializationDecl *PS2,
+                                        SourceLocation Loc, Sema &SemaRef) {
+  
+  SmallVector<DeducedTemplateArgument, 4> Deduced;
+  TemplateDeductionInfo Info(Loc);
   // C++ [temp.class.order]p1:
   //   For two class template partial specializations, the first is at least as
   //   specialized as the second if, given the following rewrite to two

   // know that every template parameter is deducible from the class
   // template partial specialization's template arguments, for
   // example.
-  SmallVector<DeducedTemplateArgument, 4> Deduced;
-  TemplateDeductionInfo Info(Loc);
+  
+  QualType PT1 = GetMoreSpecializedPartialSpecializationImpl::
+      getTypeOfPartialSpecialization(PS1);
+  QualType PT2 = GetMoreSpecializedPartialSpecializationImpl::
+      getTypeOfPartialSpecialization(PS2);
 
-  QualType PT1 = PS1->getInjectedSpecializationType();
-  QualType PT2 = PS2->getInjectedSpecializationType();
-
   // Determine whether PS1 is at least as specialized as PS2
   Deduced.resize(PS2->getTemplateParameters()->size());
-  bool Better1 = !DeduceTemplateArgumentsByTypeMatch(*this,
+  bool Better1 = !DeduceTemplateArgumentsByTypeMatch(SemaRef,
                                             PS2->getTemplateParameters(),
                                             PT2, PT1, Info, Deduced, TDF_None,
                                             /*PartialOrdering=*/true,
                                             /*RefParamComparisons=*/0);
   if (Better1) {
     SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),Deduced.end());
-    InstantiatingTemplate Inst(*this, Loc, PS2, DeducedArgs, Info);
+    Sema::InstantiatingTemplate Inst(SemaRef, Loc, PS2, DeducedArgs, Info);
     Better1 = !::FinishTemplateArgumentDeduction(
-        *this, PS2, PS1->getTemplateArgs(), Deduced, Info);
+        SemaRef, PS2, PS1->getTemplateArgs(), Deduced, Info);
   }
 
   // Determine whether PS2 is at least as specialized as PS1
   Deduced.clear();
   Deduced.resize(PS1->getTemplateParameters()->size());
   bool Better2 = !DeduceTemplateArgumentsByTypeMatch(
-      *this, PS1->getTemplateParameters(), PT1, PT2, Info, Deduced, TDF_None,
+      SemaRef, PS1->getTemplateParameters(), PT1, PT2, Info, Deduced, TDF_None,
       /*PartialOrdering=*/true,
       /*RefParamComparisons=*/0);
   if (Better2) {
     SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
                                                  Deduced.end());
-    InstantiatingTemplate Inst(*this, Loc, PS1, DeducedArgs, Info);
+    Sema::InstantiatingTemplate Inst(SemaRef, Loc, PS1, DeducedArgs, Info);
     Better2 = !::FinishTemplateArgumentDeduction(
-        *this, PS1, PS2->getTemplateArgs(), Deduced, Info);
+        SemaRef, PS1, PS2->getTemplateArgs(), Deduced, Info);
   }
+  // Neither is better than the other, so if one is more specialized than the
+  // other based on the number of empty template parameter lists, choose that.
+  // This tie breaker can be used in such scenarios:
+  //
+  // template <class T> struct O {
+  //   template <class U1, class U2> struct L {
+  //     int p;
+  //   };
+  //   template <class U1> struct L<typename U1::type, U1 *> {
+  //     int k;
+  //   };
+  // };
+  // 
+  // struct HasType {
+  //   typedef HasType *type;
+  // };
+  // 
+  // template <> template <class U1> struct O<HasType>::L<U1 *, U1 *> {
+  //  int j;
+  // };
+  // 
+  // int x0 = O<HasType>::L<HasType*, HasType*>().j; 
+  // In this instance, both partials make it through to this step since
+  // neither maps to a previous declaration of the other.
+  if (Better1 == Better2) {
+    auto GetPrototypePartialSpecialization = [](PartialSpecializationDecl *D) {
+      PartialSpecializationDecl *It = D;
+      while (It->getInstantiatedFromMember()) {
+        if (It->isMemberSpecialization())
+          return It;
+        It = It->getInstantiatedFromMember();
+      }
+      return It;
+    };
+    unsigned NumOfEmptyTPLSin1 = SemaRef.getNumberOfEmptyTemplateParameterLists(
+        GetPrototypePartialSpecialization(PS1));
+    unsigned NumOfEmptyTPLSin2 = SemaRef.getNumberOfEmptyTemplateParameterLists(
+        GetPrototypePartialSpecialization(PS2));
+    if (NumOfEmptyTPLSin1 == NumOfEmptyTPLSin2)
+      return 0;
+    else 
+      return (NumOfEmptyTPLSin1 > NumOfEmptyTPLSin2) ? PS1 : PS2;
+  }
 
-  if (Better1 == Better2)
-    return 0;
-
   return Better1 ? PS1 : PS2;
 }
+/// \brief Returns the more specialized class template partial specialization
+/// according to the rules of partial ordering of class template partial
+/// specializations (C++ [temp.class.order]).
+///
+/// \param PS1 the first class template partial specialization
+///
+/// \param PS2 the second class template partial specialization
+///
+/// \returns the more specialized class template partial specialization. If
+/// neither partial specialization is more specialized, returns NULL.
+ClassTemplatePartialSpecializationDecl *
+Sema::getMoreSpecializedPartialSpecialization(
+                                  ClassTemplatePartialSpecializationDecl *PS1,
+                                  ClassTemplatePartialSpecializationDecl *PS2,
+                                              SourceLocation Loc) {
+  return getMoreSpecializedPartialSpecializationImpl(PS1, PS2, Loc, *this);
+}
 
 /// TODO: Unify with ClassTemplatePartialSpecializationDecl version?
 ///       May require unifying ClassTemplate(Partial)SpecializationDecl and

 Sema::getMoreSpecializedPartialSpecialization(
     VarTemplatePartialSpecializationDecl *PS1,
     VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc) {
-  SmallVector<DeducedTemplateArgument, 4> Deduced;
-  TemplateDeductionInfo Info(Loc);
 
-  assert(PS1->getSpecializedTemplate() == PS2->getSpecializedTemplate() &&
+  assert(PS1->getSpecializedTemplate()->getCanonicalDecl() ==
+             PS2->getSpecializedTemplate()->getCanonicalDecl() &&
          "the partial specializations being compared should specialize"
          " the same template.");
-  TemplateName Name(PS1->getSpecializedTemplate());
-  TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
-  QualType PT1 = Context.getTemplateSpecializationType(
-      CanonTemplate, PS1->getTemplateArgs().data(),
-      PS1->getTemplateArgs().size());
-  QualType PT2 = Context.getTemplateSpecializationType(
-      CanonTemplate, PS2->getTemplateArgs().data(),
-      PS2->getTemplateArgs().size());
-
-  // Determine whether PS1 is at least as specialized as PS2
-  Deduced.resize(PS2->getTemplateParameters()->size());
-  bool Better1 = !DeduceTemplateArgumentsByTypeMatch(
-      *this, PS2->getTemplateParameters(), PT2, PT1, Info, Deduced, TDF_None,
-      /*PartialOrdering=*/true,
-      /*RefParamComparisons=*/0);
-  if (Better1) {
-    SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
-                                                 Deduced.end());
-    InstantiatingTemplate Inst(*this, Loc, PS2, DeducedArgs, Info);
-    Better1 = !::FinishTemplateArgumentDeduction(*this, PS2,
-                                                 PS1->getTemplateArgs(),
-                                                 Deduced, Info);
-  }
-
-  // Determine whether PS2 is at least as specialized as PS1
-  Deduced.clear();
-  Deduced.resize(PS1->getTemplateParameters()->size());
-  bool Better2 = !DeduceTemplateArgumentsByTypeMatch(*this,
-                                            PS1->getTemplateParameters(),
-                                            PT1, PT2, Info, Deduced, TDF_None,
-                                            /*PartialOrdering=*/true,
-                                            /*RefParamComparisons=*/0);
-  if (Better2) {
-    SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),Deduced.end());
-    InstantiatingTemplate Inst(*this, Loc, PS1, DeducedArgs, Info);
-    Better2 = !::FinishTemplateArgumentDeduction(*this, PS1,
-                                                 PS2->getTemplateArgs(),
-                                                 Deduced, Info);
-  }
-
-  if (Better1 == Better2)
-    return 0;
-
-  return Better1? PS1 : PS2;
+  return getMoreSpecializedPartialSpecializationImpl(PS1, PS2, Loc, *this);
 }
 
 static void

lib/Sema/SemaTemplateInstantiate.cpp

 // Template Instantiation Support
 //===----------------------------------------------------------------------===/
 
+//===----------------------------------------------------------------------===/
+// Template Instantiation Support
+//===----------------------------------------------------------------------===/
+
 /// \brief Retrieve the template argument list(s) that should be used to
 /// instantiate the definition of the given declaration.
 ///

 /// instantiating the definition of the given declaration, \p D. This is
 /// used to determine the proper set of template instantiation arguments for
 /// friend function template specializations.
-MultiLevelTemplateArgumentList
-Sema::getTemplateInstantiationArgs(NamedDecl *D, 
-                                   const TemplateArgumentList *Innermost,
-                                   bool RelativeToPrimary,
-                                   const FunctionDecl *Pattern) {
+///
+/// \param TPLsOfDeclBeingSubstituted If non-empty, indicates the
+/// template-parameter-lists of the prototype declaration whose pattern is
+/// being used to instantiate 'D'.
+///
+
+MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs(
+    NamedDecl *D, const TemplateArgumentList *Innermost, bool RelativeToPrimary,
+    const FunctionDecl *Pattern,
+    ArrayRef<TemplateParameterList *> TPLsOfDeclBeingSubstituted) {
   // Accumulate the set of template argument lists in this structure.
   MultiLevelTemplateArgumentList Result;
 
+  // Track the decl context with the TPLsOfDeclBeingSubstituted. Each time a TPL
+  // is consumed off that array - increment this.
+  // '0' is the current innermost  DeclContext.  It is used to determine the
+  // index within TPLsOfDeclBeingSubstituted if supplied.
+  unsigned TPLsDeclContextTracker = 0;
   if (Innermost)
     Result.addOuterTemplateArguments(Innermost);
   
   DeclContext *Ctx = dyn_cast<DeclContext>(D);
   if (!Ctx) {
     Ctx = D->getDeclContext();
+    ++TPLsDeclContextTracker;
 
     // Add template arguments from a variable template instantiation.
     if (VarTemplateSpecializationDecl *Spec =

         return Result;
       }
     }
-  }
-  
+  } 
   while (!Ctx->isFileContext()) {
+    TemplateParameterList *const CurTPL = [&] {
+      const int NumberOfTPLsOfDeclBeingSubstituted =
+          TPLsOfDeclBeingSubstituted.size();
+      const int CurTPLIndex =
+          NumberOfTPLsOfDeclBeingSubstituted
+              ? NumberOfTPLsOfDeclBeingSubstituted - 1 - TPLsDeclContextTracker
+              : -1;
+      return CurTPLIndex >= 0 ? TPLsOfDeclBeingSubstituted[CurTPLIndex]
+                              : nullptr;
+    }();
     // Add template arguments from a class template instantiation.
     if (ClassTemplateSpecializationDecl *Spec
           = dyn_cast<ClassTemplateSpecializationDecl>(Ctx)) {
-      // We're done when we hit an explicit specialization.
-      if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization &&
-          !isa<ClassTemplatePartialSpecializationDecl>(Spec))
+      // We're done when we hit an explicit specialization and we don't have 
+      // the TPLs of the declaration being substituted to determine if specializations
+      // from ancestral templates are appropriate for use.
+      if ((Spec->getSpecializationKind() == TSK_ExplicitSpecialization &&
+           !isa<ClassTemplatePartialSpecializationDecl>(Spec))) {
+        // If the ctx is an explicit declaration or if the declaration of the
+        // pattern that will be used for instantiation has an empty tpl at this
+        // level, it clearly does not need to be substituted into it at this
+        // level.
+        // For e.g. consider the pattern declaration #1 below:
+        //  template<class T> struct A {
+        //    template<class U> struct B {
+        //    };
+        //  };
+        //  template<> template<class U> struct A<int>::B<U*> { }; #1
+        //
+        // If we have a TPL at this level and it is empty, consume it via incrementing OuterDeclContextIndex.
+        if (CurTPL) {
+          if (!CurTPL->size())
+            ++TPLsDeclContextTracker;
+          goto loop_next; 
+        }
         break;
-
-      Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs());
-      
-      // If this class template specialization was instantiated from a 
+      }
+      // If the tpl of the decl being substituted into is empty, ignore the
+      // template arguments at that level and continue with the outer ones.
+      // For e.g.
+      //  template<class T> template<>
+      //   struct A<T>::B<char> { ... };
+      //  while instantiating A<int>::B<char> --> ignore the <char>
+      if (!CurTPL || CurTPL->size())
+        Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs());
+      // If this class template specialization was instantiated from a
       // specialized member that is a class template, we're done.
       assert(Spec->getSpecializedTemplate() && "No class template?");
       if (Spec->getSpecializedTemplate()->isMemberSpecialization())
         break;
-    }
+    } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Ctx)) {
       // Add template arguments from a function template specialization.
-    else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Ctx)) {
       if (!RelativeToPrimary &&
           (Function->getTemplateSpecializationKind() == 
                                                   TSK_ExplicitSpecialization &&

         const TemplateSpecializationType *TST =
             cast<TemplateSpecializationType>(Context.getCanonicalType(T));
         Result.addOuterTemplateArguments(
               llvm::makeArrayRef(TST->getArgs(), TST->getNumArgs()));
         if (ClassTemplate->isMemberSpecialization())
           break;
       }
     }
-
+    ++TPLsDeclContextTracker;
+loop_next:
     Ctx = Ctx->getParent();
     RelativeToPrimary = false;
   }

   return Result;
 }
 
+
 bool Sema::ActiveTemplateInstantiation::isInstantiationRecord() const {
   switch (Kind) {
   case TemplateInstantiation:

     type = arg.getIntegralType();
   }
   if (result.isInvalid()) return ExprError();
-
   Expr *resultExpr = result.take();
   return SemaRef.Owned(new (SemaRef.Context)
                 SubstNonTypeTemplateParmExpr(type,

   // Handle references to non-type template parameters and non-type template
   // parameter packs.
   if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) {
-    if (NTTP->getDepth() < TemplateArgs.getNumLevels())
+    if (NTTP->getDepth() < TemplateArgs.getNumLevels()) {
+      // Do nothing to invented dummy template arguments.
+      if (getSema().InventedDummyNonTypeTemplateArguments.count(E))
+        return ExprResult(E);
       return TransformTemplateParmRefExpr(E, NTTP);
+    }
     
     // We have a non-type template parameter that isn't fully substituted;
     // FindInstantiatedDecl will find it in the local instantiation scope.

       Instantiation->setInvalidDecl();
       continue;
     }
+    // Do not eagerly transform partial or explicit specialization declarations.
+    Decl *NewMember = nullptr;
+    if (!isa<ClassTemplateSpecializationDecl>(Member) &&
+        !isa<VarTemplateSpecializationDecl>(Member) && 
+        !isa<ClassScopeFunctionSpecializationDecl>(Member))
+      NewMember = Instantiator.Visit(Member);
 
-    Decl *NewMember = Instantiator.Visit(Member);
     if (NewMember) {
       if (FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) {
         Fields.push_back(Field);

   if (!Instantiation->isInvalidDecl()) {
     // Perform any dependent diagnostics from the pattern.
     PerformDependentDiagnostics(Pattern, TemplateArgs);
-
-    // Instantiate any out-of-line class template partial
-    // specializations now.
-    for (TemplateDeclInstantiator::delayed_partial_spec_iterator
-              P = Instantiator.delayed_partial_spec_begin(),
-           PEnd = Instantiator.delayed_partial_spec_end();
-         P != PEnd; ++P) {
-      if (!Instantiator.InstantiateClassTemplatePartialSpecialization(
-              P->first, P->second)) {
-        Instantiation->setInvalidDecl();
-        break;
-      }
-    }
-
-    // Instantiate any out-of-line variable template partial
-    // specializations now.
-    for (TemplateDeclInstantiator::delayed_var_partial_spec_iterator
-              P = Instantiator.delayed_var_partial_spec_begin(),
-           PEnd = Instantiator.delayed_var_partial_spec_end();
-         P != PEnd; ++P) {
-      if (!Instantiator.InstantiateVarTemplatePartialSpecialization(
-              P->first, P->second)) {
-        Instantiation->setInvalidDecl();
-        break;
-      }
-    }
   }
 
   // Exit the scope of this instantiation.

 }
 
 namespace {
-  /// \brief A partial specialization whose template arguments have matched
-  /// a given template-id.
+  // Help map types from Class/Var Partial specailizations back to their
+  // template decls - without requiring an inheritance relationship.
+  struct TemplateDeclTypeMapper {
+    static VarTemplateDecl
+    getTypeOfPrimaryTemplate(VarTemplatePartialSpecializationDecl *);
+    static ClassTemplateDecl
+    getTypeOfPrimaryTemplate(ClassTemplatePartialSpecializationDecl *);
+    static CXXRecordDecl getTypeOfPatternDecl(ClassTemplateDecl *);
+    static ClassTemplatePartialSpecializationDecl
+    getTypeOfPartialSpecializationDecl(ClassTemplateDecl *);
+    static ClassTemplateSpecializationDecl
+    getTypeOfExplicitSpecializationDecl(ClassTemplateDecl *);
+
+    static VarDecl getTypeOfPatternDecl(VarTemplateDecl *);
+    static VarTemplatePartialSpecializationDecl
+    getTypeOfPartialSpecializationDecl(VarTemplateDecl *);
+    static VarTemplateSpecializationDecl
+    getTypeOfExplicitSpecializationDecl(VarTemplateDecl *);
+    static ClassTemplateDecl *getDescribedTemplate(const CXXRecordDecl *D) {
+      return D->getDescribedClassTemplate();
+    }
+    static VarTemplateDecl *getDescribedTemplate(const VarDecl *D) {
+      return D->getDescribedVarTemplate();
+    }
+
+    static FunctionDecl getTypeOfPatternDecl(FunctionTemplateDecl *);
+
+  };
+
+template <class PrimaryTemplateDecl>
+std::tuple<TemplateParameterList *,
+           const decltype(TemplateDeclTypeMapper::getTypeOfPatternDecl(
+               static_cast<PrimaryTemplateDecl *>(nullptr))) *> 
+getInnermostTemplateParameterListAndPatternDecl(const Decl *D) {
+  typedef decltype(TemplateDeclTypeMapper::getTypeOfPatternDecl(
+      static_cast<PrimaryTemplateDecl *>(nullptr))) PatternDecl;
+
+  typedef decltype(TemplateDeclTypeMapper::getTypeOfPartialSpecializationDecl(
+      static_cast<PrimaryTemplateDecl *>(nullptr))) PartialSpecializationDecl;
+
+  typedef decltype(TemplateDeclTypeMapper::getTypeOfExplicitSpecializationDecl(
+      static_cast<PrimaryTemplateDecl *>(nullptr))) ExplicitSpecializationDecl;
+
+  TemplateParameterList *InnerMostTPL = nullptr;
+  const PatternDecl *PatternD = nullptr;
+
+  if (auto *TD = dyn_cast<PrimaryTemplateDecl>(D)) {
+    InnerMostTPL = TD->getTemplateParameters();
+    PatternD = TD->getTemplatedDecl();
+  } else if (auto *PSD = dyn_cast<PartialSpecializationDecl>(D)) {
+    InnerMostTPL = PSD->getTemplateParameters();
+    PatternD = PSD;
+  } else if (auto *ESD = dyn_cast<ExplicitSpecializationDecl>(D)) {
+    if (ESD->isExplicitSpecialization()) {
+      // If this was declared as an explicit specialization, all the TPLs
+      // are included in the getTemplateParameterList(i) info...
+      InnerMostTPL = 0;
+      PatternD = ESD;
+    } else {
+      // If this is implicitly instantiated, then use the template
+      // parameter lists of the template that we were instantiated from.
+      auto PrimaryOrPartialTemplate = ESD->getSpecializedTemplateOrPartial();
+      if (PrimaryOrPartialTemplate.is<PartialSpecializationDecl *>())
+        return getInnermostTemplateParameterListAndPatternDecl<
+            PrimaryTemplateDecl>(
+            PrimaryOrPartialTemplate.get<PartialSpecializationDecl *>());
+      return getInnermostTemplateParameterListAndPatternDecl<
+          PrimaryTemplateDecl>(ESD->getSpecializedTemplate());
+    }
+  } else if (auto *PD = dyn_cast<PatternDecl>(D)) {
+    if (PrimaryTemplateDecl *TD =
+            TemplateDeclTypeMapper::getDescribedTemplate(PD)) {
+      PatternD = PD;
+      InnerMostTPL = TD->getTemplateParameters();
+    } else {
+      //PD->dump();
+      //llvm_unreachable(
+      //    "The above decl must be a pattern decl of some template!");
+    }
+  }
+  return std::make_tuple(InnerMostTPL, PatternD);
+}
+
+std::tuple<TemplateParameterList *, const FunctionDecl *> 
+getInnermostTemplateParameterListAndPatternDeclIfFunctionDecl(const Decl *D) {
+  
+  TemplateParameterList *InnerMostTPL = nullptr;
+  const FunctionDecl *PatternD = nullptr;
+  
+  if (const auto *TD = dyn_cast<FunctionTemplateDecl>(D)) {
+    InnerMostTPL = TD->getTemplateParameters();
+    PatternD = TD->getTemplatedDecl();
+  } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
+    if (FD->getDescribedFunctionTemplate())
+      return getInnermostTemplateParameterListAndPatternDeclIfFunctionDecl(
+          FD->getDescribedFunctionTemplate());
+    else if (FD->isFunctionTemplateSpecialization()) {
+      return getInnermostTemplateParameterListAndPatternDeclIfFunctionDecl(
+          FD->getPrimaryTemplate());
+    }
+  } else if (const auto *CFD =
+                 dyn_cast<ClassScopeFunctionSpecializationDecl>(D)) {
+    D->dump();
+    llvm_unreachable("We do not know how to process class scope function specialization decl!");
+  }
+  return std::make_tuple(InnerMostTPL, PatternD);
+}
+
+template <class TagOrDeclaratorTy>
+void getTemplateParameterListsOfOutOfLineDeclImpl(
+    TagOrDeclaratorTy *D, SmallVectorImpl<TemplateParameterList *> &TPLs) {
+  
+  for (unsigned I = 0; I != D->getNumTemplateParameterLists(); ++I)
+    TPLs.push_back(D->getTemplateParameterList(I));
+}
+
+template <class TagT, class DeclaratorT>
+void getTemplateParameterListsOfOutOfLineDecl(
+    const llvm::PointerUnion<TagT *, DeclaratorT *> &TagOrDeclaratorPattern,
+    SmallVectorImpl<TemplateParameterList *> &TPLs) {
+  if (TagOrDeclaratorPattern.is<TagT *>())
+    return getTemplateParameterListsOfOutOfLineDeclImpl(
+        TagOrDeclaratorPattern.get<TagT *>(), TPLs);
+  else
+    return getTemplateParameterListsOfOutOfLineDeclImpl(
+        TagOrDeclaratorPattern.get<DeclaratorT *>(), TPLs);
+}
+} // end anonymous ns
+
+SmallVector<TemplateParameterList *, 4>
+Sema::getTemplateParameterListsOfDeclaration(const Decl *D) {
+  SmallVector<TemplateParameterList *, 4> TPLs;
+  llvm::PointerUnion<const TagDecl *, const DeclaratorDecl *> PatternDecl;
+  TemplateParameterList *InnerMostTPL = 0;
+  std::tie(InnerMostTPL, PatternDecl) =
+      getInnermostTemplateParameterListAndPatternDecl<ClassTemplateDecl>(D);
+  if (!PatternDecl)
+    std::tie(InnerMostTPL, PatternDecl) =
+        getInnermostTemplateParameterListAndPatternDecl<VarTemplateDecl>(D);
+  if (!PatternDecl)
+    std::tie(InnerMostTPL, PatternDecl) =
+        getInnermostTemplateParameterListAndPatternDeclIfFunctionDecl(D);
+  // Now that we have our original Decl separated into the PatternDecl and
+  // any Innermost TPL of the template, determine whether we have enclosing 
+  // templates, and add their TPLs to this template.  
+  if (PatternDecl) {
+    // Add any enclosing template parameter lists ...
+    if (!D->isOutOfLine()) {
+      if (const DeclContext *ParentDC = D->getDeclContext()) {
+        if (isa<CXXRecordDecl>(ParentDC)) {
+          auto ParentTPLs = getTemplateParameterListsOfDeclaration(
+              cast<CXXRecordDecl>(ParentDC));
+          TPLs.append(ParentTPLs.begin(), ParentTPLs.end());
+        }
+      }
+    } else {  // For out of line declarations use the PatternDecl.
+      getTemplateParameterListsOfOutOfLineDecl(PatternDecl, TPLs);
+    }
+    if (InnerMostTPL)
+      TPLs.push_back(InnerMostTPL);
+  }
+  return TPLs;
+}
+
+unsigned Sema::getNumberOfEmptyTemplateParameterLists(const Decl *D) {
+  unsigned num = 0;
+  for (auto *tpl : getTemplateParameterListsOfDeclaration(D)) {
+    if (!tpl->size())
+      ++num;
+  }
+  return num;
+}
+
+namespace {
+// See definition below for comments.
+template <class PrimaryTemplateDecl> class BestSpecializationFinder;
+}
+
+// A class that abstracts out the search for all partial specializations
+// linked to a primary template.  This checks for explicitly specialized
+// partial specializations and if the primary template is not explicitly
+// specialized, it checks for non-explicitly specialized partial 
+// specializations.  It substitutes the appropriate template arguments
+// from outer scopes as necessary.  Additionally, it checks to see if
+// it can determine the most specialized partial specialization, and if not
+// informs of ambiguity.  
+//
+// Parameterization supports the two kinds of partial specialization
+// declarations allowed in C++:
+//  - ClassTemplatePartialSpecializationDecl
+//  - VarTemplatePartialSpecializationDecl
+
+template <class PrimaryTemplateDecl> class ::BestSpecializationFinder {
+
+  typedef decltype(TemplateDeclTypeMapper::getTypeOfPartialSpecializationDecl(
+      static_cast<PrimaryTemplateDecl *>(nullptr))) PartialSpecializationDecl;
+
+  typedef decltype(TemplateDeclTypeMapper::getTypeOfExplicitSpecializationDecl(
+      static_cast<PrimaryTemplateDecl *>(nullptr))) ExplicitSpecializationDecl;
+  // Clang represents explicit specialization AST nodes and any instantiation
+  // of a template node with the same type.  We differentiate based on the
+  // kind of the specialization it is and whether it is an instantiation.
+  typedef decltype(TemplateDeclTypeMapper::getTypeOfExplicitSpecializationDecl(
+      static_cast<PrimaryTemplateDecl *>(nullptr))) TemplateSpecializationDecl;
+
+  Sema &SemaRef;
+  PrimaryTemplateDecl *const TemplateBeingInstantiated;
+  CXXRecordDecl *const ParentClassOfTemplateBeingInstantiated;
+
   struct PartialSpecMatchResult {
-    ClassTemplatePartialSpecializationDecl *Partial;
-    TemplateArgumentList *Args;
+    PartialSpecializationDecl *const Partial;
+    TemplateArgumentList *const Args;
+    PartialSpecMatchResult() : Partial(nullptr), Args(nullptr) {}
+    PartialSpecMatchResult(PartialSpecializationDecl *Partial,
+                           TemplateArgumentList *Args)
+        : Partial(Partial), Args(Args) {}
   };
+
+public:
+  BestSpecializationFinder(Sema & S, PrimaryTemplateDecl * CurTemplate)
+      : SemaRef(S), TemplateBeingInstantiated(CurTemplate),
+        ParentClassOfTemplateBeingInstantiated(
+            isa<CXXRecordDecl>(CurTemplate->getDeclContext())
+                ? cast<CXXRecordDecl>(CurTemplate->getDeclContext())
+                      ->getCanonicalDecl()
+                : 0) {}
+  // A convenience typedef for partial and explicit specialization vectors
+  typedef SmallVector<PartialSpecializationDecl *, 4> PartialSpecVectorTy;
+  typedef SmallVector<ExplicitSpecializationDecl *, 4> ExplicitSpecVectorTy;
+  
+  template <class PartialOrExplicitSpecializationDecl>
+  PartialOrExplicitSpecializationDecl *substOuterTemplateArgs(
+      PartialOrExplicitSpecializationDecl *Spec,
+      SourceLocation PointOfInstantiation) const {
+
+    clang::MultiLevelTemplateArgumentList OuterTemplateArgs =
+        SemaRef.getTemplateInstantiationArgs(
+            TemplateBeingInstantiated, nullptr, false, nullptr,
+            SemaRef.getTemplateParameterListsOfDeclaration(Spec));
+
+    Sema::InstantiatingTemplate Inst(SemaRef, PointOfInstantiation, Spec);
+    // If we have exceeded the maximum recursion instantiation depth, return
+    // null.
+    // FIXME: What diagnostic should we emit here?
+    if (Inst.isInvalid())
+      return nullptr;
+
+    // Enter the DeclContext that contains the partial spec we will be
+    // substituting into ...
+    // We don't use PushDeclContext because we don't have a scope.
+    Sema::ContextRAII SavedContext(SemaRef,
+                                   ParentClassOfTemplateBeingInstantiated);
+
+    EnterExpressionEvaluationContext EvalContext(SemaRef,
+                                                 Sema::PotentiallyEvaluated);
+
+    Sema::SFINAETrap IntroduceSFINAE(SemaRef, true);
+
+    TemplateDeclInstantiator DeclInstantiator(
+        SemaRef, ParentClassOfTemplateBeingInstantiated, OuterTemplateArgs);
+
+    return cast_or_null<PartialOrExplicitSpecializationDecl>(
+        DeclInstantiator.Visit(Spec));
+  }
+
+private:
+  // Iterate through all Ancestor templates and find all partial
+  // specializations from each one.
+  PartialSpecVectorTy getAllPartialSpecializationsFromAncestorTemplates()
+      const {
+
+    PartialSpecVectorTy AllPartialSpecs;
+    PrimaryTemplateDecl *TemplateIt = TemplateBeingInstantiated;
+    while (PrimaryTemplateDecl *const AncestorTemplate =
+               TemplateIt->getInstantiatedFromMemberTemplate()) {
+      PartialSpecVectorTy PSpecs;
+      AncestorTemplate->getPartialSpecializations(PSpecs);
+      AllPartialSpecs.append(PSpecs.begin(), PSpecs.end());
+      TemplateIt = AncestorTemplate;
+    }
+    return AllPartialSpecs;
+  }
+
+  // Iterate through all Ancestor templates and find all explicit
+  // specializations from each one.
+  ExplicitSpecVectorTy getAllExplicitSpecializationsFromAncestorTemplates()
+      const {
+    ExplicitSpecVectorTy AllExplicitSpecs;
+    PrimaryTemplateDecl *TemplateIt = TemplateBeingInstantiated;
+    while (PrimaryTemplateDecl *const AncestorTemplate =
+               TemplateIt->getInstantiatedFromMemberTemplate()) {
+      for (auto *Specs : AncestorTemplate->specializations()) {
+        if (Specs->isExplicitSpecialization())
+          AllExplicitSpecs.push_back(Specs);
+      }
+      TemplateIt = AncestorTemplate;
+    }
+    return AllExplicitSpecs;
+  }
+  // Iterate through the partial specializations associated with all ancestor
+  // templates
+  //  - substitute the outer enclosing arguments of the nested
+  //    TemplateBeingInstanted.
+  PartialSpecVectorTy getRelevantPartialSpecializationsFromAncestorTemplates(
+      SourceLocation PointOfInstantiation) const {
+    PartialSpecVectorTy AllPartialSpecs =
+        getAllPartialSpecializationsFromAncestorTemplates();
+    PartialSpecVectorTy RelevantPartialSpecs;
+    for (PartialSpecializationDecl *const APSpec : AllPartialSpecs) {
+      if (PartialSpecializationDecl *PSD =
+              substOuterTemplateArgs(APSpec, PointOfInstantiation)) {
+        RelevantPartialSpecs.push_back(PSD);
+      }
+    }
+    return RelevantPartialSpecs;
+  }
+
+  // Iterate through the explicit specializations associated with all ancestor
+  // templates
+  //  - substitute the outer enclosing arguments of the nested
+  //  TemplateBeingInstanted.
+  ExplicitSpecVectorTy getRelevantExplicitSpecializationsFromAncestorTemplates(
+      SourceLocation PointOfInstantiation) const {
+    auto AllExplicitSpecs = getAllExplicitSpecializationsFromAncestorTemplates();
+    ExplicitSpecVectorTy RelevantExplicitSpecs;
+    for (ExplicitSpecializationDecl *const AESpec : AllExplicitSpecs) {
+      if (ExplicitSpecializationDecl *ESD =
+              substOuterTemplateArgs(AESpec, PointOfInstantiation)) {
+        RelevantExplicitSpecs.push_back(ESD);
+      }
+    }
+    return RelevantExplicitSpecs;
+  }
+  /// \brief Retrieve all the partial specializations associated with 'D'.
+  /// If D is not explicitly specialized, retrieve partial specializations
+  /// from the original template (substituting into the outer template
+  /// parameters as necessary at point-of-instantiation).
+  PartialSpecVectorTy
+  getAllPartialSpecializationsFromWhichToSelectTheMostSpecializedTemplate(
+      SourceLocation POI) const {
+
+    PartialSpecVectorTy AllPartialSpecs;
+    TemplateBeingInstantiated->getPartialSpecializations(AllPartialSpecs);
+    // 14.5.5.3/2 [temp.class.spec.mfunc]:
+    // '... If the primary member template is explicitly specialized for a given
+    // (implicit) specialization of the enclosing class template, the partial
+    // specializations of the member template are ignored for this
+    // specialization of the enclosing class template. If a partial
+    // specialization of the member template is explicitly specialized for a
+    // given (implicit) specialization of the enclosing class template, the
+    // primary member template and its other partial specializations are still
+    // considered for this specialization of the enclosing class template.
+    //
+    // i.e: If the primary member template is an explicit specialization that is
+    // specialized as a member template itself, do not consider any partial
+    // specializations that have not themselves been similarly explicitly
+    // specialized. For e.g.
+    //    template<class T> struct L {
+    //      template<class U> struct M { int i; };     // #1
+    //      template<class U> struct M<U**> { int j; }; // #2
+    //    };
+    //    template<> template<class U>
+    //    struct L<int>::M<U*> { int k; };             // #3
+    //
+    //    template<> template<class U>
+    //    struct L<int>::M { int l; };                 // #4
+    //  For the primary template at #4, consider #3 but not #2
+    if (!TemplateBeingInstantiated->isMemberSpecialization()) {
+      PartialSpecVectorTy APSpecs =
+          getRelevantPartialSpecializationsFromAncestorTemplates(POI);
+      AllPartialSpecs.append(APSpecs.begin(), APSpecs.end());
+    }
+    return AllPartialSpecs;
+  }
+
+  ExplicitSpecVectorTy
+  getAllExplicitSpecializationsFromWhichToSelectTheMostSpecializedTemplate(
+      SourceLocation POI) const {
+
+    ExplicitSpecVectorTy AllExplicitSpecs;
+    for (auto *Spec : TemplateBeingInstantiated->specializations())
+      if (Spec->isExplicitSpecialization())
+        AllExplicitSpecs.push_back(Spec);
+    // FIXME: This comment is wrong!
+    // i.e: If the primary member template is an explicit specialization that is
+    // specialized as a member template itself, do not consider any partial
+    // specializations that have not themselves been similarly explicitly
+    // specialized. For e.g.
+    //    template<class T> struct L {
+    //      template<class U> struct M { int i; };     // #1
+    //      template<class U> struct M<U**> { int j; }; // #2
+    //    };
+    //    template<> template<class U>
+    //    struct L<int>::M<U*> { int k; };             // #3
+    //
+    //    template<> template<class U>
+    //    struct L<int>::M { int l; };                 // #4
+    //  For the primary template at #4, consider #3 but not #2
+    if (!TemplateBeingInstantiated->isMemberSpecialization()) {
+      auto AESpecs =
+          getRelevantExplicitSpecializationsFromAncestorTemplates(POI);
+      AllExplicitSpecs.append(AESpecs.begin(), AESpecs.end());
+    }
+    return AllExplicitSpecs;
+  }
+
+  // Given template args, craft a templateid name using the
+  // TemplateBeingInstantiated.
+  std::string makeUnqualifiedTemplateIdName(
+      const TemplateArgumentList &TemplateArgs) const {
+    auto Policy = SemaRef.getPrintingPolicy();
+    std::string out;
+    llvm::raw_string_ostream OS(out);
+    TemplateBeingInstantiated->getNameForDiagnostic(OS, Policy,
+                                                    /*Qualified*/ false);
+    TemplateSpecializationType::PrintTemplateArgumentList(
+        OS, TemplateArgs.data(), TemplateArgs.size(), Policy);
+    OS.flush();
+    return out;
+  }
+
+  void complainPartialSpecializationSearchWasAmbiguous(
+      const TemplateArgumentList &TemplateArgs,
+      ArrayRef<PartialSpecMatchResult> Matched,
+      SourceLocation PointOfInstantiation) const {
+    // Partial ordering did not produce a clear winner. Complain.
+    assert(Matched.size() > 1);
+    SemaRef.Diag(PointOfInstantiation,
+                 diag::err_partial_spec_ordering_ambiguous)
+        << makeUnqualifiedTemplateIdName(TemplateArgs);
+
+    // Print the matching partial specializations.
+    for (SmallVectorImpl<PartialSpecMatchResult>::const_iterator
+             P = Matched.begin(),
+             PEnd = Matched.end();
+         P != PEnd; ++P)
+      SemaRef.Diag(P->Partial->getLocation(), diag::note_partial_spec_match)
+          << SemaRef.getTemplateArgumentBindingsText(
+              P->Partial->getTemplateParameters(), *P->Args);
+  }
+  void complainExplicitSpecializationSearchWasAmbiguous(
+      const TemplateArgumentList &TemplateArgs,
+      const ExplicitSpecVectorTy &Matched,
+      SourceLocation PointOfInstantiation) const {
+    // Partial ordering did not produce a clear winner. Complain.
+    assert(Matched.size() > 1);
+    SemaRef.Diag(PointOfInstantiation,
+                 diag::err_explicit_spec_ordering_ambiguous)
+        << makeUnqualifiedTemplateIdName(TemplateArgs);
+
+    // Print the matching explicit specializations.
+    for (auto *ESpec : Matched)
+      SemaRef.Diag(ESpec->getLocation(), diag::note_explicit_spec_match)
+          << ESpec;
+  }
+
+public:
+  ExplicitSpecializationDecl *getBestExplicitSpecialization(
+      bool &Ambiguous, ArrayRef<TemplateArgument> TemplateArgs,
+      SourceLocation PointOfInstantiation) {
+    // These are ordered so that member explicit specializations
+    // from the most specialized context are at a lower index
+    // than those in a less specialized context.
+    // template<class T> struct A {
+    //   template<class U> struct B {
+    //     template<class V> struct C { };
+    //   };
+    // };
+    // template<class T> template<class U> template<>
+    //  struct A<T>::B<U>::C<U> { ... }
+    // template<class T> template<class U> template<>
+    //  struct A<T>::B<U>::C<int> { ... }
+    // template<class T> template<class U> template<>
+    //  struct A<T>::B<U>::C<int> { ... }
+    // template<> template<> template<>
+    //  struct A<int>::B<float>::C<int> { }; <-- this is ordered ahead
+    ExplicitSpecVectorTy AllExplicitSpecs =
+        getAllExplicitSpecializationsFromWhichToSelectTheMostSpecializedTemplate(
+            PointOfInstantiation);
+    ExplicitSpecVectorTy Matched;
+    const llvm::FoldingSetNodeID TemplateArgsID = [&] {
+      llvm::FoldingSetNodeID ID;
+      ExplicitSpecializationDecl::Profile(ID, TemplateArgs.data(),
+                                          TemplateArgs.size(),
+                                          SemaRef.getASTContext());
+      return ID;
+    }();
+    for (auto *ESpec : AllExplicitSpecs) {
+      llvm::FoldingSetNodeID ID;
+      ExplicitSpecializationDecl::Profile(ID, ESpec->getTemplateArgs().data(),
+                                          ESpec->getTemplateArgs().size(),
+                                          SemaRef.getASTContext());
+      if (ID == TemplateArgsID)
+        Matched.push_back(ESpec);
+    }
+    if (!Matched.size())
+      return nullptr;
+    if (Matched.size() == 1)
+      return Matched.back();
+
+    std::sort(Matched.begin(), Matched.end(),
+              [this](ExplicitSpecializationDecl *D1,
+                         ExplicitSpecializationDecl *D2) {
+      return SemaRef.getNumberOfEmptyTemplateParameterLists(D1) >
+             SemaRef.getNumberOfEmptyTemplateParameterLists(D2);
+    });
+    const unsigned NumEmptyTPLs1 =
+        SemaRef.getNumberOfEmptyTemplateParameterLists(Matched[0]);
+    const unsigned NumEmptyTPLs2 =
+        SemaRef.getNumberOfEmptyTemplateParameterLists(Matched[1]);
+    if (NumEmptyTPLs1 == NumEmptyTPLs2) {
+      complainExplicitSpecializationSearchWasAmbiguous(Matched[0]->getTemplateArgs(), Matched,
+                                                       PointOfInstantiation);
+      Ambiguous = true;
+    }
+    return Matched[0];
+  }
+
+  PartialSpecMatchResult getBestPartialSpecialization(
+      bool &Ambiguous, const TemplateArgumentList &TemplateArgs,
+      SourceLocation PointOfInstantiation) {
+    PartialSpecVectorTy PartialSpecs =
+        getAllPartialSpecializationsFromWhichToSelectTheMostSpecializedTemplate(
+            PointOfInstantiation);
+    if (!PartialSpecs.size())
+      return PartialSpecMatchResult();
+
+    // Store all the matched partial specializations, so that in case of
+    // ambiguity we can emit an informative diagnostic.
+    SmallVector<PartialSpecMatchResult, 4> Matched;
+    TemplateSpecCandidateSet FailedCandidates(PointOfInstantiation);
+    for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
+      PartialSpecializationDecl *Partial = PartialSpecs[I];
+      TemplateDeductionInfo Info(FailedCandidates.getLocation());
+      if (Sema::TemplateDeductionResult Result =
+              SemaRef.DeduceTemplateArguments(Partial, TemplateArgs, Info)) {
+        // Store the failed-deduction information for use in diagnostics, later.
+        // TODO: Actually use the failed-deduction info?
+        FailedCandidates.addCandidate().set(
+            Partial, MakeDeductionFailureInfo(SemaRef.Context, Result, Info));
+        (void)Result;
+      } else {
+        Matched.push_back(PartialSpecMatchResult(Partial, Info.take()));
+      }
+    }
+
+    // If we're dealing with a member template where the template parameters
+    // have been instantiated, this provides the original template parameters
+    // from which the member template's parameters were instantiated.
+
+    if (Matched.size() >= 1) {
+      SmallVectorImpl<PartialSpecMatchResult>::iterator Best = Matched.begin();
+      if (Matched.size() == 1) {
+        //   -- If exactly one matching specialization is found, the
+        //      instantiation is generated from that specialization.
+        // We don't need to do anything for this.
+      } else {
+        //   -- If more than one matching specialization is found, the
+        //      partial order rules (14.5.4.2) are used to determine
+        //      whether one of the specializations is more specialized
+        //      than the others. If none of the specializations is more
+        //      specialized than all of the other matching
+        //      specializations, then the use of the class template is
+        //      ambiguous and the program is ill-formed.
+        for (SmallVectorImpl<PartialSpecMatchResult>::iterator
+                 P = Best + 1,
+                 PEnd = Matched.end();
+             P != PEnd; ++P) {
+          if (SemaRef.getMoreSpecializedPartialSpecialization(
+                  P->Partial, Best->Partial, PointOfInstantiation) ==
+              P->Partial)
+            Best = P;
+        }
+
+        // Determine if the best partial specialization is more specialized than
+        // the others.
+        Ambiguous = false;
+        for (SmallVectorImpl<PartialSpecMatchResult>::iterator
+                 P = Matched.begin(),
+                 PEnd = Matched.end();
+             P != PEnd; ++P) {
+          if (P != Best &&
+              SemaRef.getMoreSpecializedPartialSpecialization(
+                  P->Partial, Best->Partial, PointOfInstantiation) !=
+                  Best->Partial) {
+            Ambiguous = true;
+            complainPartialSpecializationSearchWasAmbiguous(
+                TemplateArgs, Matched, PointOfInstantiation);
+            return *Best;
+          }
+        }
+      }
+      return *Best;
+    }
+    return PartialSpecMatchResult();
+  }
+};
+
+std::tuple<ClassTemplatePartialSpecializationDecl *,
+           const TemplateArgumentList *, bool>
+Sema::getMostSpecializedPartialSpecialization(
+    ClassTemplateDecl *Template, const TemplateArgumentList &TemplateArgs,
+    SourceLocation PointOfInstantiation) {
+  bool Ambiguous = false;
+  auto PartialSpecAndTemplateArgs =
+      BestSpecializationFinder<ClassTemplateDecl>(
+          *this, Template).getBestPartialSpecialization(Ambiguous, TemplateArgs,
+                                                        PointOfInstantiation);
+  return std::make_tuple(PartialSpecAndTemplateArgs.Partial,
+                         PartialSpecAndTemplateArgs.Args, Ambiguous);
 }
 
+std::tuple<VarTemplatePartialSpecializationDecl *,
+           const TemplateArgumentList *, bool>
+Sema::getMostSpecializedPartialSpecialization(
+    VarTemplateDecl *Template, const TemplateArgumentList &TemplateArgs,
+    SourceLocation PointOfInstantiation) {
+  bool Ambiguous = false;
+  auto PartialSpecAndTemplateArgs =
+      BestSpecializationFinder<VarTemplateDecl>(
+          *this, Template).getBestPartialSpecialization(Ambiguous, TemplateArgs,
+                                                        PointOfInstantiation);
+  return std::make_tuple(PartialSpecAndTemplateArgs.Partial,
+                         PartialSpecAndTemplateArgs.Args, Ambiguous);
+}
+
+ClassTemplateSpecializationDecl *
+Sema::getBestExplicitSpecialization(bool &Ambiguous,
+                                    ClassTemplateDecl *Template,
+                                    ArrayRef<TemplateArgument> TemplateArgs,
+                                    SourceLocation PointOfInstantiation) {
+  return BestSpecializationFinder<ClassTemplateDecl>(*this, Template)
+      .getBestExplicitSpecialization(Ambiguous, TemplateArgs,
+                                     PointOfInstantiation);
+}
+
+VarTemplateSpecializationDecl *
+Sema::getBestExplicitSpecialization(bool &Ambiguous, VarTemplateDecl *Template,
+                                    ArrayRef<TemplateArgument> TemplateArgs,
+                                    SourceLocation PointOfInstantiation) {
+  return BestSpecializationFinder<VarTemplateDecl>(*this, Template)
+      .getBestExplicitSpecialization(Ambiguous, TemplateArgs,
+                                     PointOfInstantiation);
+}
+
 bool Sema::InstantiateClassTemplateSpecialization(
     SourceLocation PointOfInstantiation,
     ClassTemplateSpecializationDecl *ClassTemplateSpec,

     return true;
   
   ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate();
-  CXXRecordDecl *Pattern = 0;
-
+  
   // C++ [temp.class.spec.match]p1:
   //   When a class template is used in a context that requires an
   //   instantiation of the class, it is necessary to determine

   //   matching the template arguments of the class template
   //   specialization with the template argument lists of the partial
   //   specializations.
-  typedef PartialSpecMatchResult MatchResult;
-  SmallVector<MatchResult, 4> Matched;
-  SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
-  Template->getPartialSpecializations(PartialSpecs);
-  TemplateSpecCandidateSet FailedCandidates(PointOfInstantiation);
-  for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
-    ClassTemplatePartialSpecializationDecl *Partial = PartialSpecs[I];
-    TemplateDeductionInfo Info(FailedCandidates.getLocation());
-    if (TemplateDeductionResult Result
-          = DeduceTemplateArguments(Partial,
-                                    ClassTemplateSpec->getTemplateArgs(),
-                                    Info)) {
-      // Store the failed-deduction information for use in diagnostics, later.
-      // TODO: Actually use the failed-deduction info?
-      FailedCandidates.addCandidate()
-          .set(Partial, MakeDeductionFailureInfo(Context, Result, Info));
-      (void)Result;
-    } else {
-      Matched.push_back(PartialSpecMatchResult());
-      Matched.back().Partial = Partial;
-      Matched.back().Args = Info.take();
-    }
+  ClassTemplatePartialSpecializationDecl *BestPartialSpec = nullptr;
+  const TemplateArgumentList *BestPartialDeducedArgs = nullptr;
+  bool PartialSpecIsAmbiguous = false;
+  std::tie(BestPartialSpec, BestPartialDeducedArgs, PartialSpecIsAmbiguous) =
+      getMostSpecializedPartialSpecialization(
+          Template, ClassTemplateSpec->getTemplateArgs(), PointOfInstantiation);
+  if (PartialSpecIsAmbiguous) {
+    ClassTemplateSpec->setInvalidDecl();
+    return true;
   }
-
-  // If we're dealing with a member template where the template parameters
-  // have been instantiated, this provides the original template parameters
-  // from which the member template's parameters were instantiated.
-
-  if (Matched.size() >= 1) {
-    SmallVectorImpl<MatchResult>::iterator Best = Matched.begin();
-    if (Matched.size() == 1) {
-      //   -- If exactly one matching specialization is found, the
-      //      instantiation is generated from that specialization.
-      // We don't need to do anything for this.
-    } else {
-      //   -- If more than one matching specialization is found, the
-      //      partial order rules (14.5.4.2) are used to determine
-      //      whether one of the specializations is more specialized
-      //      than the others. If none of the specializations is more
-      //      specialized than all of the other matching
-      //      specializations, then the use of the class template is
-      //      ambiguous and the program is ill-formed.
-      for (SmallVectorImpl<MatchResult>::iterator P = Best + 1,
-                                               PEnd = Matched.end();
-           P != PEnd; ++P) {
-        if (getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial,
-                                                    PointOfInstantiation) 
-              == P->Partial)
-          Best = P;
-      }
-      
-      // Determine if the best partial specialization is more specialized than
-      // the others.
-      bool Ambiguous = false;
-      for (SmallVectorImpl<MatchResult>::iterator P = Matched.begin(),
-                                               PEnd = Matched.end();
-           P != PEnd; ++P) {
-        if (P != Best &&
-            getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial,
-                                                    PointOfInstantiation)
-              != Best->Partial) {
-          Ambiguous = true;
-          break;
-        }
-      }
-       
-      if (Ambiguous) {
-        // Partial ordering did not produce a clear winner. Complain.
-        ClassTemplateSpec->setInvalidDecl();
-        Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
-          << ClassTemplateSpec;
-        
-        // Print the matching partial specializations.
-        for (SmallVectorImpl<MatchResult>::iterator P = Matched.begin(),
-                                                 PEnd = Matched.end();
-             P != PEnd; ++P)
-          Diag(P->Partial->getLocation(), diag::note_partial_spec_match)
-            << getTemplateArgumentBindingsText(
-                                            P->Partial->getTemplateParameters(),
-                                               *P->Args);
-
-        return true;
-      }
-    }
-    
+  CXXRecordDecl *Pattern = 0;
+  if (BestPartialSpec) {
     // Instantiate using the best class template partial specialization.
-    ClassTemplatePartialSpecializationDecl *OrigPartialSpec = Best->Partial;
+    ClassTemplatePartialSpecializationDecl *OrigPartialSpec =
+      BestPartialSpec;
     while (OrigPartialSpec->getInstantiatedFromMember()) {
       // If we've found an explicit specialization of this class template,
       // stop here and use that as the pattern.

     }
     
     Pattern = OrigPartialSpec;
-    ClassTemplateSpec->setInstantiationOf(Best->Partial, Best->Args);
+    ClassTemplateSpec->setInstantiationOf(BestPartialSpec,
+                                          BestPartialDeducedArgs);
   } else {
     //   -- If no matches are found, the instantiation is generated
     //      from the primary template.

     Pattern = OrigTemplate->getTemplatedDecl();
   }
 
-  bool Result = InstantiateClass(PointOfInstantiation, ClassTemplateSpec, 
-                                 Pattern,
-                                getTemplateInstantiationArgs(ClassTemplateSpec),
-                                 TSK,
-                                 Complain);
+  bool Result = InstantiateClass(
+      PointOfInstantiation, ClassTemplateSpec, Pattern,
+      getTemplateInstantiationArgs(
+          ClassTemplateSpec, /*Innermost*/ nullptr, /*RelativeToPrimary*/ false,
+          /*FunctionPattern*/ nullptr,
+          getTemplateParameterListsOfDeclaration(Pattern)),
+      TSK, Complain);
 
   return Result;
 }

lib/Sema/SemaTemplateInstantiateDecl.cpp

 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/PrettyDeclStackTrace.h"
 #include "clang/Sema/Template.h"
+#include "clang/Sema/TemplateDeduction.h"
 
 using namespace clang;
 

   }
 
   Owner->addDecl(Inst);
-
-  if (!PrevClassTemplate) {
-    // Queue up any out-of-line partial specializations of this member
-    // class template; the client will force their instantiation once
-    // the enclosing class has been instantiated.
-    SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
-    D->getPartialSpecializations(PartialSpecs);
-    for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
-      if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
-        OutOfLinePartialSpecs.push_back(std::make_pair(Inst, PartialSpecs[I]));
-  }
-
   return Inst;
 }
 

 
   Owner->addDecl(Inst);
 
-  if (!PrevVarTemplate) {
-    // Queue up any out-of-line partial specializations of this member
-    // variable template; the client will force their instantiation once
-    // the enclosing class has been instantiated.
-    SmallVector<VarTemplatePartialSpecializationDecl *, 4> PartialSpecs;
-    D->getPartialSpecializations(PartialSpecs);
-    for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
-      if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
-        OutOfLineVarPartialSpecs.push_back(
-            std::make_pair(Inst, PartialSpecs[I]));
-  }
-
   return Inst;
 }
 

 
 Decl *
 TemplateDeclInstantiator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
+  return VisitFunctionTemplateDecl(D, false);
+}
+Decl *TemplateDeclInstantiator::VisitFunctionTemplateDecl(
+    FunctionTemplateDecl *D, bool IsCheckingDependentClassScopeSpecialization) {
   // Create a local instantiation scope for this function template, which
   // will contain the instantiations of the template parameters and then get
   // merged with the local instantiation scope for the function template

     InstTemplate->setInstantiatedFromMemberTemplate(D);
 
   // Make declarations visible in the appropriate context.
-  if (!isFriend) {
+  if (!isFriend && !IsCheckingDependentClassScopeSpecialization) {
     Owner->addDecl(InstTemplate);
-  } else if (InstTemplate->getDeclContext()->isRecord() &&
+  } else if (isFriend && InstTemplate->getDeclContext()->isRecord() &&
              !D->getPreviousDecl()) {
     SemaRef.CheckFriendAccess(InstTemplate);
   }

   return Function;
 }
 
-Decl *
-TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D,
-                                      TemplateParameterList *TemplateParams,
-                                      bool IsClassScopeSpecialization) {
+
+namespace {
+class MethodSpecializationFinder;
+}
+
+class ::MethodSpecializationFinder {
+  Sema &SemaRef;
+  FunctionTemplateDecl *TemplateBeingInstantiated;
+  CXXRecordDecl *ParentClassOfTemplateBeingInstantiated;
+  typedef SmallVector<CXXMethodDecl *, 4> ExplicitSpecVectorTy;
+  mutable std::map<CXXMethodDecl *, TemplateArgumentListInfo>
+  SubstitutedExplicitTemplateArgsMap;
+  CXXMethodDecl *substOuterTemplateArgs(
+      CXXMethodDecl *Spec, SourceLocation PointOfInstantiation) const {
+
+    clang::MultiLevelTemplateArgumentList OuterTemplateArgs =
+        SemaRef.getTemplateInstantiationArgs(
+            TemplateBeingInstantiated, nullptr, false, nullptr,
+            SemaRef.getTemplateParameterListsOfDeclaration(Spec));
+
+    Sema::InstantiatingTemplate Inst(SemaRef, PointOfInstantiation, Spec);
+    // If we have exceeded the maximum recursion instantiation depth, return
+    // null.
+    // FIXME: What diagnostic should we emit here?
+    if (Inst.isInvalid())
+      return nullptr;
+
+    // Enter the DeclContext that contains the partial spec we will be
+    // substituting into ...
+    // We don't use PushDeclContext because we don't have a scope.
+    Sema::ContextRAII SavedContext(SemaRef,
+                                   ParentClassOfTemplateBeingInstantiated);
+
+    EnterExpressionEvaluationContext EvalContext(SemaRef, Sema::Unevaluated);
+
+    Sema::SFINAETrap IntroduceSFINAE(SemaRef, true);
+
+    TemplateDeclInstantiator DeclInstantiator(
+        SemaRef, ParentClassOfTemplateBeingInstantiated, OuterTemplateArgs);
+    // Transform any explicitly specified
+    FunctionTemplateSpecializationInfo *SpecFSI = Spec->getTemplateSpecializationInfo();
+    if (SpecFSI->TemplateArgumentsAsWritten) {
+      TemplateArgumentListInfo &SubstArgs =
+          SubstitutedExplicitTemplateArgsMap[Spec];
+      if (SemaRef.Subst(SpecFSI->TemplateArgumentsAsWritten->getTemplateArgs(),
+                        SpecFSI->TemplateArgumentsAsWritten->NumTemplateArgs,
+                        SubstArgs, OuterTemplateArgs))
+        return nullptr;
+    }
+    return cast_or_null<CXXMethodDecl>(
+        DeclInstantiator.VisitCXXMethodDecl(Spec, 0, true));
+  }
+  ExplicitSpecVectorTy getAllExplicitSpecializationsFromAncestorTemplates()
+      const {
+    ExplicitSpecVectorTy AllExplicitSpecs;
+    FunctionTemplateDecl *TemplateIt = TemplateBeingInstantiated;
+    while (FunctionTemplateDecl *const AncestorTemplate =
+               TemplateIt->getInstantiatedFromMemberTemplate()) {
+      for (FunctionDecl *Spec : AncestorTemplate->specializations()) {
+        assert(isa<CXXMethodDecl>(Spec));
+        assert(Spec->getTemplateSpecializationInfo() || Spec->isInvalidDecl());
+
+        if (!Spec->isInvalidDecl() &&
+            Spec->getTemplateSpecializationInfo()->isExplicitSpecialization())
+          AllExplicitSpecs.push_back(cast<CXXMethodDecl>(Spec));
+      }
+      TemplateIt = AncestorTemplate;
+    }
+    return AllExplicitSpecs;
+  }
+
+  // Iterate through the explicit specializations associated with all ancestor
+  // templates
+  //  - substitute the outer enclosing arguments of the nested
+  //  TemplateBeingInstanted.
+  ExplicitSpecVectorTy getRelevantExplicitSpecializationsFromAncestorTemplates(
+      SourceLocation PointOfInstantiation) const {
+    auto AllExplicitSpecs =
+        getAllExplicitSpecializationsFromAncestorTemplates();
+    ExplicitSpecVectorTy RelevantExplicitSpecs;
+    for (CXXMethodDecl *const AESpec : AllExplicitSpecs) {
+      if (CXXMethodDecl *ESD =
+              substOuterTemplateArgs(AESpec, PointOfInstantiation)) {
+        RelevantExplicitSpecs.push_back(ESD);
+      }
+    }
+    return RelevantExplicitSpecs;
+  }
+
+public:
+  MethodSpecializationFinder(Sema &SemaRef,
+                             FunctionTemplateDecl *TemplateBeingInstantiated)
+      : SemaRef(SemaRef), TemplateBeingInstantiated(TemplateBeingInstantiated),
+        ParentClassOfTemplateBeingInstantiated(
+            cast<CXXRecordDecl>(TemplateBeingInstantiated->getDeclContext())) {}
+  ExplicitSpecVectorTy getMatchingExplicitSpecializations(
+      SourceLocation POI, ArrayRef<TemplateArgument> TArgs) const {
+    const llvm::FoldingSetNodeID DesiredSpecID = ([&] {
+      llvm::FoldingSetNodeID ID;
+      FunctionTemplateSpecializationInfo::Profile(
+          ID, TArgs.data(), TArgs.size(), SemaRef.Context);
+      return ID;
+    }());
+    ExplicitSpecVectorTy MatchingSpecs;
+    for (CXXMethodDecl *Spec :
+         getRelevantExplicitSpecializationsFromAncestorTemplates(POI)) {
+      
+      assert(!Spec->isDependentContext());
+      assert(Spec->getInstantiatedFromMemberFunction() &&
+             "This specialization must have been instantiated from an explicit "
+             "specialization");
+      assert(isa<CXXMethodDecl>(Spec->getInstantiatedFromMemberFunction()));
+      CXXMethodDecl *ProtoSpec =
+          cast<CXXMethodDecl>(Spec->getInstantiatedFromMemberFunction());
+
+      // This contains deduced arguments info only at the innermost function
+      // specialization level - that is those arguments deduced against the
+      // member template to form the explicit specialization.
+      FunctionTemplateSpecializationInfo *ProtoFSI =
+          ProtoSpec->getTemplateSpecializationInfo();
+      assert(ProtoFSI && "This specialization must have been instantiated from "
+                         "an explicit specialization");
+
+      // FIXME: If ProtoFSI has any dependent template arguments (i.e. it has
+      // dummy arguments substituted in), only then do we need
+      // to deduce the template arguments.
+
+      SmallVector<DeducedTemplateArgument, 4> DeducedArgs;
+      sema::TemplateDeductionInfo DeductionInfo(POI);
+      Sema::TemplateDeductionResult Result =
+          clang::DeduceTemplateArgumentsByTypeMatchForExplicitSpecializations(
+              SemaRef, TemplateBeingInstantiated, Spec,
+              // Pass in any substituted template arguments explicitly specified
+              (ProtoFSI->TemplateArgumentsAsWritten
+                   ? &SubstitutedExplicitTemplateArgsMap[ProtoSpec]
+                   : nullptr),
+              DeductionInfo, DeducedArgs);
+      // This must succeed - we are only doing this to harvest out the deduced
+      // arguments.
+      assert(Result == Sema::TDK_Success);
+      // Convert the array of DeducedTemplateArguments into an array of
+      // TemplateArguments so that we don't clobber any data when
+      // crawling the array for determining its hash.
+      SmallVector<TemplateArgument, 4> TemplateArgs;
+      for (const auto &DTA : DeducedArgs)
+        TemplateArgs.push_back(DTA);
+      llvm::FoldingSetNodeID SpecID;
+      FunctionTemplateSpecializationInfo::Profile(
+          SpecID, TemplateArgs.data(), TemplateArgs.size(), SemaRef.Context);
+      if (SpecID == DesiredSpecID)
+        MatchingSpecs.push_back(Spec);
+    }
+    return MatchingSpecs;
+  }
+};
+
+Decl *TemplateDeclInstantiator::VisitCXXMethodDecl(
+    CXXMethodDecl *D, TemplateParameterList *TemplateParams,
+    bool IsClassScopeSpecialization) {
   FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
   if (FunctionTemplate && !TemplateParams) {
     // We are creating a function template specialization from a function

     // If we already have a function template specialization, return it.
     if (SpecFunc)
       return SpecFunc;
+    // Search for explicit specializations from instantiated from
+    // member templates.
+    // Only do this if we are not declaring a dependent class scope explicit
+    // specialization but rather trying to use one.
+    //   - i.e. the decl context can not be dependent.
+    // FIXME: This is an ugly hack - see comment in Sema.h for one suggestion
+    // regarding a more robust fix.
+    auto IsUndergoingTemplateArgumentDeductionWhileMethodSpecializationBeingDeclared =
+        [](CXXMethodDecl *Pattern, Sema &S) {
+      if (S.PatternOfMethodSpecializationBeingDeclared.size())
+        return S.PatternOfMethodSpecializationBeingDeclared.back()
+                   ->getCanonicalDecl() == Pattern->getCanonicalDecl();
+      return false;
+    };
+    if (!D->getDeclContext()->isDependentContext() &&
+        !FunctionTemplate->isMemberSpecialization() &&
+        !IsUndergoingTemplateArgumentDeductionWhileMethodSpecializationBeingDeclared(
+            D, SemaRef)) {
+      Sema::ActiveTemplateInstantiation &CurInstantiation =
+          SemaRef.ActiveTemplateInstantiations.back();
+      SourceLocation PointOfInstantiation =
+          CurInstantiation.PointOfInstantiation;
+      MethodSpecializationFinder MSF(SemaRef, FunctionTemplate);
+      SmallVector<CXXMethodDecl *, 4> ExplicitSpecs =
+          MSF.getMatchingExplicitSpecializations(
+              CurInstantiation.PointOfInstantiation, Innermost);
+      if (const unsigned NumMatches = ExplicitSpecs.size()) {
+        CXXMethodDecl *MatchedExplicitDecl = ExplicitSpecs.back(); 
+        if (NumMatches == 1)
+          return MatchedExplicitDecl;
+        SemaRef.Diag(PointOfInstantiation,
+                     diag::err_explicit_spec_ordering_ambiguous)
+            << FunctionTemplate;
+
+        // FIXME: Since we are in a SFINAE context? Is that why these do not get
+        // printed? :(
+        for (auto *ESpec : ExplicitSpecs)
+          SemaRef.Diag(ESpec->getLocation(), diag::note_explicit_spec_match)
+              << ESpec;
+        MatchedExplicitDecl->setInvalidDecl();
+        return MatchedExplicitDecl;
+      }
+    }
   }
 
   bool isFriend;

       Previous.clear();
   }
 
-  if (!IsClassScopeSpecialization)
-    SemaRef.CheckFunctionDeclaration(0, Method, Previous, false);
+  SemaRef.CheckFunctionDeclaration(0, Method, Previous, false);
 
   if (D->isPure())
     SemaRef.CheckPureMethod(Method, SourceRange());

 
   // Add this partial specialization to the set of class template partial
   // specializations.
-  if (!PrevDecl)
-    InstClassTemplate->AddSpecialization(InstD, InsertPos);
+  //if (!PrevDecl)
+  //  InstClassTemplate->AddSpecialization(InstD, InsertPos);
 
   // Substitute the nested name specifier, if any.
   if (SubstQualifier(D, InstD))

   InstD->setTemplateKeywordLoc(D->getTemplateKeywordLoc());
 
   Owner->addDecl(InstD);
   
   // Instantiate the members of the class-scope explicit specialization eagerly.
   // We don't have support for lazy instantiation of an explicit specialization
   // yet, and MSVC eagerly instantiates in this case.
-  if (D->isThisDeclarationADefinition() &&
-      SemaRef.InstantiateClass(D->getLocation(), InstD, D, TemplateArgs,
-                               TSK_ImplicitInstantiation,
-                               /*Complain=*/true))
-    return 0;
+  // FIXME: Should this be allowed only in microsoft mode, now that we support 
+  // relaxed instantiation of class scope explicit specializations.
+  //if (D->isThisDeclarationADefinition() &&
+  //    SemaRef.InstantiateClass(D->getLocation(), InstD, D, TemplateArgs,
+  //                             TSK_ImplicitInstantiation,
+  //                             /*Complain=*/true))
+  //  return 0;
 
   return InstD;
 }

           const_cast<TemplateArgumentListInfo &>(VarTemplateArgsInfo), false,
           Converted))
     return 0;
   
   // Find the variable template specialization declaration that
   // corresponds to these arguments.
-  void *InsertPos = 0;
-  if (VarTemplateSpecializationDecl *VarSpec = VarTemplate->findSpecialization(
-          Converted.data(), Converted.size(), InsertPos))
-    // If we already have a variable template specialization, return it.
-    return VarSpec;
-
-  return VisitVarTemplateSpecializationDecl(VarTemplate, D, InsertPos,
+  return VisitVarTemplateSpecializationDecl(VarTemplate, D, nullptr,
                                             VarTemplateArgsInfo, Converted);
 }
 

     VarTemplateDecl *VarTemplate, VarDecl *D, void *InsertPos,
     const TemplateArgumentListInfo &TemplateArgsInfo,
     llvm::ArrayRef<TemplateArgument> Converted) {
   
   // If this is the variable for an anonymous struct or union,
   // instantiate the anonymous struct/union type first.
   if (const RecordType *RecordTy = D->getType()->getAs<RecordType>())

         << D->isStaticDataMember() << DI->getType();
     return 0;
   }
  
   // Build the instantiated declaration
-  VarTemplateSpecializationDecl *Var = VarTemplateSpecializationDecl::Create(
+  VarTemplateSpecializationDecl *NewVar = VarTemplateSpecializationDecl::Create(
       SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
       VarTemplate, DI->getType(), DI, D->getStorageClass(), Converted.data(),
       Converted.size());
-  Var->setTemplateArgsInfo(TemplateArgsInfo);
-  if (InsertPos)
-    VarTemplate->AddSpecialization(Var, InsertPos);
-
+  NewVar->setTemplateArgsInfo(TemplateArgsInfo);
+  
   // Substitute the nested name specifier, if any.
-  if (SubstQualifier(D, Var))
+  if (SubstQualifier(D, NewVar))
     return 0;
 
-  SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs,
+  SemaRef.BuildVariableInstantiation(NewVar, D, TemplateArgs, LateAttrs,
                                      Owner, StartingScope);
 
-  return Var;
+  return NewVar;
 }
 
 Decl *TemplateDeclInstantiator::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {

                                                     InstTemplateArgs,
                                                     CanonType);
 
-  if (PrevDecl) {
-    // We've already seen a partial specialization with the same template
-    // parameters and template arguments. This can happen, for example, when
-    // substituting the outer template arguments ends up causing two
-    // class template partial specializations of a member class template
-    // to have identical forms, e.g.,
-    //
-    //   template<typename T, typename U>
-    //   struct Outer {
-    //     template<typename X, typename Y> struct Inner;
-    //     template<typename Y> struct Inner<T, Y>;
-    //     template<typename Y> struct Inner<U, Y>;
-    //   };
-    //
-    //   Outer<int, int> outer; // error: the partial specializations of Inner
-    //                          // have the same signature.
-    SemaRef.Diag(PartialSpec->getLocation(), diag::err_partial_spec_redeclared)
-      << WrittenTy->getType();
-    SemaRef.Diag(PrevDecl->getLocation(), diag::note_prev_partial_spec_here)
-      << SemaRef.Context.getTypeDeclType(PrevDecl);
-    return 0;
-  }
-
-
   // Create the class template partial specialization declaration.
   ClassTemplatePartialSpecializationDecl *InstPartialSpec
     = ClassTemplatePartialSpecializationDecl::Create(SemaRef.Context,

 
   InstPartialSpec->setInstantiatedFromMember(PartialSpec);
   InstPartialSpec->setTypeAsWritten(WrittenTy);
-
-  // Add this partial specialization to the set of class template partial
-  // specializations.
-  ClassTemplate->AddPartialSpecialization(InstPartialSpec, /*InsertPos=*/0);
   return InstPartialSpec;
 }
 

   TypeSourceInfo *WrittenTy = SemaRef.Context.getTemplateSpecializationTypeInfo(
       TemplateName(VarTemplate), PartialSpec->getLocation(), InstTemplateArgs,
       CanonType);
-
-  if (PrevDecl) {
-    // We've already seen a partial specialization with the same template
-    // parameters and template arguments. This can happen, for example, when
-    // substituting the outer template arguments ends up causing two
-    // variable template partial specializations of a member variable template
-    // to have identical forms, e.g.,
-    //
-    //   template<typename T, typename U>
-    //   struct Outer {
-    //     template<typename X, typename Y> pair<X,Y> p;
-    //     template<typename Y> pair<T, Y> p;
-    //     template<typename Y> pair<U, Y> p;
-    //   };
-    //
-    //   Outer<int, int> outer; // error: the partial specializations of Inner
-    //                          // have the same signature.
-    SemaRef.Diag(PartialSpec->getLocation(),
-                 diag::err_var_partial_spec_redeclared)
-        << WrittenTy->getType();
-    SemaRef.Diag(PrevDecl->getLocation(),
-                 diag::note_var_prev_partial_spec_here);
-    return 0;
-  }
-
   // Do substitution on the type of the declaration
   TypeSourceInfo *DI = SemaRef.SubstType(
       PartialSpec->getTypeSourceInfo(), TemplateArgs,

 
   // Add this partial specialization to the set of variable template partial
   // specializations. The instantiation of the initializer is not necessary.
-  VarTemplate->AddPartialSpecialization(InstPartialSpec, /*InsertPos=*/0);
-
+  
   SemaRef.BuildVariableInstantiation(InstPartialSpec, PartialSpec, TemplateArgs,
                                      LateAttrs, Owner, StartingScope);
 

     Sema::ContextRAII savedContext(*this, Function);
 
     MultiLevelTemplateArgumentList TemplateArgs =
-      getTemplateInstantiationArgs(Function, 0, false, PatternDecl);
+      getTemplateInstantiationArgs(Function, 0, false, PatternDecl, 
+      getTemplateParameterListsOfDeclaration(PatternDecl));
 
     addInstantiatedParametersToScope(*this, Function, PatternDecl, Scope,
                                      TemplateArgs);

   VarTemplateSpecializationDecl *VarSpec =
       dyn_cast<VarTemplateSpecializationDecl>(Var);
   VarDecl *PatternDecl = 0, *Def = 0;
-  MultiLevelTemplateArgumentList TemplateArgs =
-      getTemplateInstantiationArgs(Var);
-
+  MultiLevelTemplateArgumentList TemplateArgs;
   if (VarSpec) {
     // If this is a variable template specialization, make sure that it is
     // non-dependent, then find its instantiation pattern.

            "Only instantiate variable template specializations that are "
            "not type-dependent");
     (void)InstantiationDependent;
+    const bool IsInstantiatedFromDependentExplicitSpecialization =
+        ([](VarTemplateSpecializationDecl *VarSpec) {
+          if (auto *OldVarSpec = VarSpec->getInstantiatedFromStaticDataMember())
+            return OldVarSpec->getTemplateSpecializationKind() ==
+                       TSK_ExplicitSpecialization &&
+                   !isa<VarTemplatePartialSpecializationDecl>(OldVarSpec);
+          return false;
+        }(VarSpec));
 
-    // Find the variable initialization that we'll be substituting. If the
-    // pattern was instantiated from a member template, look back further to
-    // find the real pattern.
-    assert(VarSpec->getSpecializedTemplate() &&
-           "Specialization without specialized template?");
-    llvm::PointerUnion<VarTemplateDecl *,
-                       VarTemplatePartialSpecializationDecl *> PatternPtr =
-        VarSpec->getSpecializedTemplateOrPartial();
-    if (PatternPtr.is<VarTemplatePartialSpecializationDecl *>()) {
-      VarTemplatePartialSpecializationDecl *Tmpl =
-          PatternPtr.get<VarTemplatePartialSpecializationDecl *>();
-      while (VarTemplatePartialSpecializationDecl *From =
-                 Tmpl->getInstantiatedFromMember()) {
-        if (Tmpl->isMemberSpecialization())
-          break;
+    // If this was instantiated from an explicit specialization declared within
+    // a dependent context (i.e. within a class template) - the pattern is the
+    // explicit specialization's pattern.
+    if (IsInstantiatedFromDependentExplicitSpecialization) {
+      PatternDecl = VarSpec->getInstantiatedFromStaticDataMember();
+    } else {
+      // Find the variable initialization that we'll be substituting. If the
+      // pattern was instantiated from a member template, look back further to
+      // find the real pattern.
+      assert(VarSpec->getSpecializedTemplate() &&
+             "Specialization without specialized template?");
+      llvm::PointerUnion<VarTemplateDecl *,
+                         VarTemplatePartialSpecializationDecl *> PatternPtr =
+          VarSpec->getSpecializedTemplateOrPartial();
+      // Now check to see if we explicitly declared a new partial specialization
+      // with the same type.
+      VarTemplatePartialSpecializationDecl *NewPartialSpec = nullptr;
+      const TemplateArgumentList *NewPartialSpecDeducedArgs = nullptr;
+      bool NewPartialSpecIsAmbiguous = false;
+      std::tie(NewPartialSpec, NewPartialSpecDeducedArgs,
+               NewPartialSpecIsAmbiguous) =
+          getMostSpecializedPartialSpecialization(
+              VarSpec->getSpecializedTemplate(), VarSpec->getTemplateArgs(),
+              VarSpec->getPointOfInstantiation());
+      if (NewPartialSpecIsAmbiguous)
+        return;
+      // FIXME: Check undeduced types here correctly.
+      // If we have a new partial spec, it better have the same type
+      if (NewPartialSpec) {
+        // If this instance was not instantiated from a partial specialization,
+        // or
+        // was instantiated from a different partial specialization ...
+        if (!PatternPtr.is<VarTemplatePartialSpecializationDecl *>() ||
+            PatternPtr.get<VarTemplatePartialSpecializationDecl *>() !=
+                NewPartialSpec) {
+          void *InsertPos = nullptr;
+          VarTemplateDecl *Template = VarSpec->getSpecializedTemplate();
+          const TemplateArgumentListInfo &TemplateArgs =
+              VarSpec->getTemplateArgsInfo();
+          SourceLocation TemplateNameLoc = VarSpec->getPointOfInstantiation();
+          // Check that the template argument list is well-formed for this
+          // template.
+          SmallVector<TemplateArgument, 4> Converted;
+          if (CheckTemplateArgumentList(
+                  Template, TemplateNameLoc,
+                  const_cast<TemplateArgumentListInfo &>(TemplateArgs), false,
+                  Converted))
+            return;
+          VarTemplateSpecializationDecl *NewVarSpec =
+              BuildVarTemplateInstantiation(
+                  VarSpec->getSpecializedTemplate(), NewPartialSpec,
+                  *NewPartialSpecDeducedArgs, VarSpec->getTemplateArgsInfo(),
+                  Converted, TemplateNameLoc,
+                  InsertPos /*, LateAttrs, StartingScope*/);
 
-        Tmpl = From;
+          if (!Context.hasSameType(NewVarSpec->getType(), VarSpec->getType())) {
+            // FIXME: Complain/Emit diagnostic that states we can not use a
+            // partial
+            // specialization that instantiates to a different type.
+            return;
+          }
+        }
       }
-      PatternDecl = Tmpl;
-    } else {
-      VarTemplateDecl *Tmpl = PatternPtr.get<VarTemplateDecl *>();
-      while (VarTemplateDecl *From =
-                 Tmpl->getInstantiatedFromMemberTemplate()) {
-        if (Tmpl->isMemberSpecialization())
-          break;
 
-        Tmpl = From;
+      if (NewPartialSpec ||
+          PatternPtr.is<VarTemplatePartialSpecializationDecl *>()) {
+        VarTemplatePartialSpecializationDecl *Tmpl =
+            NewPartialSpec
+                ? NewPartialSpec
+                : PatternPtr.get<VarTemplatePartialSpecializationDecl *>();
+        while (VarTemplatePartialSpecializationDecl *From =
+                   Tmpl->getInstantiatedFromMember()) {
+          if (Tmpl->isMemberSpecialization())
+            break;
+
+          Tmpl = From;
+        }
+        PatternDecl = Tmpl;
+      } else {
+        VarTemplateDecl *Tmpl = PatternPtr.get<VarTemplateDecl *>();
+        while (VarTemplateDecl *From =
+                   Tmpl->getInstantiatedFromMemberTemplate()) {
+          if (Tmpl->isMemberSpecialization())
+            break;
+
+          Tmpl = From;
+        }
+        PatternDecl = Tmpl->getTemplatedDecl();
       }
-      PatternDecl = Tmpl->getTemplatedDecl();
     }
+    TemplateArgs = getTemplateInstantiationArgs(
+        Var, /*Innermost*/ nullptr, /*RelativeToPrimary*/ false,
+        /*Function-Pattern*/ nullptr,
+        getTemplateParameterListsOfDeclaration(PatternDecl));
 
     // If this is a static data member template, there might be an
     // uninstantiated initializer on the declaration. If so, instantiate

     assert(PatternDecl && "data member was not instantiated from a template?");
     assert(PatternDecl->isStaticDataMember() && "not a static data member?");
     Def = PatternDecl->getOutOfLineDefinition();
+
+    TemplateArgs = getTemplateInstantiationArgs(Var);
   }
 
   // If we don't have a definition of the variable template, we won't perform

 NamedDecl *Sema::FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,
                           const MultiLevelTemplateArgumentList &TemplateArgs) {
   DeclContext *ParentDC = D->getDeclContext();
-  // FIXME: Parmeters of pointer to functions (y below) that are themselves 
+ 
+  // FIXME: Parmeters of pointer to functions (y below) that are themselves
   // parameters (p below) can have their ParentDC set to the translation-unit
-  // - thus we can not consistently check if the ParentDC of such a parameter 
+  // - thus we can not consistently check if the ParentDC of such a parameter
   // is Dependent or/and a FunctionOrMethod.
-  // For e.g. this code, during Template argument deduction tries to 
+  // For e.g. this code, during Template argument deduction tries to
   // find an instantiated decl for (T y) when the ParentDC for y is
-  // the translation unit.  
-  //   e.g. template <class T> void Foo(auto (*p)(T y) -> decltype(y())) {} 
+  // the translation unit.
+  //   e.g. template <class T> void Foo(auto (*p)(T y) -> decltype(y())) {}
   //   float baz(float(*)()) { return 0.0; }
   //   Foo(baz);
   // The better fix here is perhaps to ensure that a ParmVarDecl, by the time

       isa<TemplateTypeParmDecl>(D) || isa<TemplateTemplateParmDecl>(D) ||
       (ParentDC->isFunctionOrMethod() && ParentDC->isDependentContext()) ||
       (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda())) {
+
+    // Skip all the dummy template arguments that were invented to check
+    // specializations (i.e. explicit member function specializations) within
+    // a dependent context.  They should remain invisible to the generated
+    // AST.
+    if (D->isImplicit() && D->getName().slice(0, 7) == "$dummy-")
+      return D;
     // D is a local of some kind. Look into the map of local
     // declarations to their instantiations.
     typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;

lib/Sema/SemaType.cpp

         return InstantiateClassTemplateSpecialization(Loc, ClassTemplateSpec,
                                                       TSK_ImplicitInstantiation,
                                             /*Complain=*/!Diagnoser.Suppressed);
+      else if (ClassTemplateSpec->getSpecializationKind() ==
+                   TSK_ExplicitSpecialization &&
+               !ClassTemplateSpec->getDefinition() &&
+               ClassTemplateSpec->getInstantiatedFromMemberClass()) {
+        // If this is a member template explicit specialization of
+        // an enclosing class template, it might still need its
+        // outer referenced template arguments substituted into.
+        // template<class T> struct A {
+        //   template<class U> struct B;
+        //   template<> struct B<char> {
+        //     T *t;
+        //   };
+        // };
+        // 
+        CXXRecordDecl *Pattern =
+            ClassTemplateSpec->getInstantiatedFromMemberClass();
+        return InstantiateClass(
+            Pattern->getLocation(), ClassTemplateSpec, Pattern,
+            getTemplateInstantiationArgs(
+                ClassTemplateSpec, nullptr, false, nullptr,
+                getTemplateParameterListsOfDeclaration(Pattern)),
+            TSK_ImplicitInstantiation,
+            /*Complain=*/true);
+      }
     } else if (CXXRecordDecl *Rec
                  = dyn_cast<CXXRecordDecl>(Record->getDecl())) {
       CXXRecordDecl *Pattern = Rec->getInstantiatedFromMemberClass();

test/CXX/drs/dr0xx.cpp

 // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -Wno-bind-to-temporary-copy
 // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -DCPP1Y
 
 namespace dr1 { // dr1: no
   namespace X { extern "C" void dr1_f(int a = 1); }

 namespace dr44 { // dr44: yes
   struct A {
     template<int> void f();
+#ifndef CPP1Y
     template<> void f<0>(); // expected-error {{explicit specialization of 'f' in class scope}}
+#else
+  template<> void f<0>();
+#endif
   };
 }
 

test/CXX/drs/dr5xx.cpp

   template<typename T> struct S {};
   template<typename T> int v = 0; // expected-error 0-1{{extension}}
 
-  template struct S<int*>;
-  template int v<int*>;
+  template struct S<int*>; //expected-note{{first required here}}
+  template int v<int*>; //expected-note{{first required here}}
 
-  S<char&> s;
-  int k = v<char&>;
+  S<char&> s;  //expected-note{{first required here}}
+  int k = v<char&>;  //expected-note{{first required here}}
 
   // FIXME: These are both ill-formed.
-  template<typename T> struct S<T*> {};
-  template<typename T> int v<T*> = 0; // expected-error 0-1{{extension}}
+  template<typename T> struct S<T*> {}; //expected-error{{after instantiation}}
+  template<typename T> int v<T*> = 0;   //expected-error{{after instantiation}}
 
   // FIXME: These are both ill-formed.
-  template<typename T> struct S<T&> {};
-  template<typename T> int v<T&> = 0; // expected-error 0-1{{extension}}
+  template<typename T> struct S<T&> {};  //expected-error{{after instantiation}}
+  template<typename T> int v<T&> = 0;   //expected-error{{after instantiation}}
 }
 
 namespace dr518 { // dr518: yes c++11

test/CXX/temp/temp.decls/temp.class.spec/p6.cpp

 // Check for conflicts during template instantiation. 
 template<typename T, typename U>
 struct Outer {
-  template<typename X, typename Y> struct Inner;
-  template<typename Y> struct Inner<T, Y> {}; // expected-note{{previous}}
-  template<typename Y> struct Inner<U, Y> {}; // expected-error{{cannot be redeclared}}
+  template<typename X, typename Y> struct Inner { };
+  template<typename Y> struct Inner<T, Y> {}; //expected-note{{matches}}
+  template<typename Y> struct Inner<U, Y> {}; //expected-note{{matches}}
 };
 
-Outer<int, int> outer; // expected-note{{instantiation}}
+Outer<int, int> outer; 
 
+Outer<int, int>::Inner<char, char> inner47;
+
+Outer<int, int>::Inner<int, char> inner1; //expected-error{{ambiguous}}
+
 // Test specialization of class template partial specialization members.
 template<> template<typename Z>
 struct X0<float>::Inner0<Z*> {

test/CXX/temp/temp.spec/temp.expl.spec/p16.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++1y -DCPP1Y 
 template<class T> struct A { 
   void f(T);
   template<class X1> void g1(T, X1); 

   template <typename T> 
   struct Test{ 
     template <typename U> 
+ #ifdef CPP1Y
+    void get(U i) {} //expected-note{{could not match}}
+ #else
     void get(U i) {}
+ #endif
   }; 
 
   template <typename T>
   template <>
-  void Test<T>::get<double>(double i) {}  // expected-error{{cannot specialize (with 'template<>') a member of an unspecialized template}}
+ #ifdef CPP1Y
+  void Test<T>::get<double*>(double i) {} //expected-error{{no function template matches}}
+ #else
+  void Test<T>::get<double>(double i) {} //expected-error{{within class scope}}
+ #endif
 }

test/SemaCXX/cxx1y-variable-templates_in_class.cpp

 // RUN: %clang_cc1 -verify -fsyntax-only %s -Wno-c++11-extensions -Wno-c++1y-extensions -DPRECXX11
 // RUN: %clang_cc1 -std=c++11 -verify -fsyntax-only -Wno-c++1y-extensions %s
-// RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only %s
+// DISABLE: %clang_cc1 -std=c++1y -verify -fsyntax-only %s
 
 #define CONST const
 

   template<typename T> static CONST T right<T,int> = 5;
   template<typename T> CONST int right<int,T>;  // expected-error {{member 'right' declared as a template}}
   template<typename T> CONST float right<float,T> = 5;  // expected-error {{member 'right' declared as a template}}
-  template<> static CONST int right<int,int> = 7;       // expected-error {{explicit specialization of 'right' in class scope}}
-  template<> static CONST float right<float,int>;       // expected-error {{explicit specialization of 'right' in class scope}}
+  template<> static CONST int right<int,int> = 7; //expected-error{{explicit specialization}}      
+  template<> static CONST float right<float,int>;  //expected-error{{explicit specialization}}
   template static CONST int right<int,int>;     // expected-error {{template specialization requires 'template<>'}} \
                                                 // expected-error {{explicit specialization of 'right' in class scope}}
 };

     template<typename T>
     class D0a {
       template<typename U> static U Data;
-      template<typename U> static CONST U Data<U*> = U(10);  // expected-note {{previous definition is here}}
+      template<typename U> static CONST U Data<U*> = U(10);  
     };
     template<>
-    template<typename U> U D0a<float>::Data<U*> = U(100);  // expected-error {{redefinition of 'Data'}}
+    template<typename U> U D0a<float>::Data<U*> = U(100);  
 
     // FIXME: We should accept this, and the corresponding case for class
     // templates.

     template<typename T>
     class D1 {
       template<typename U> static U Data;
-      template<typename U> static CONST U Data<U*> = U(10);  // expected-note {{previous definition is here}}
+      template<typename U> static CONST U Data<U*> = U(10);  
     };
     template<>
     template<typename U> U D1<float>::Data = U(10);
     template<>
-    template<typename U> U D1<float>::Data<U*> = U(100);  // expected-error{{redefinition of 'Data'}}
+    template<typename U> U D1<float>::Data<U*> = U(100);  
   }
 
   namespace definition_after_outer_instantiation {

     // is instantiated. This is kind of implied by [temp.class.spec.mfunc]/2,
     // and matches our behavior for member class templates, but it's not clear
     // that this is intentional. See PR17294 and core-24030.
-    static_assert(S<int>::V2<int*> == 456, ""); // FIXME expected-error {{}}
-    static_assert(S<int>::V2<int&> == 789, ""); // expected-error {{}}
+    static_assert(S<int>::V2<int*> == 456, ""); 
+    //static_assert(S<int>::V2<int&> == 789, ""); 
 
     template<typename A> template<typename B> const int S<A>::V2<B&> = 789;
-    static_assert(S<int>::V2<int&> == 789, ""); // FIXME expected-error {{}}
+    static_assert(S<int>::V2<int&> == 789, ""); 
 
     // All is OK if the partial specialization is declared before the implicit
     // instantiation of the class template specialization.

test/SemaCXX/cxx1y-variable-templates_top_level.cpp

     CONST int pi2<int,T> = 3; // expected-note {{partial specialization matches [with T = int]}}
     
     void foo() {
-      int a = pi2<int,int>;  // expected-error {{ambiguous partial specializations of 'pi2<int, int>'}}
+      int a = pi2<int,int>;  // expected-error {{ambiguous partial specializations of pi2<int, int>}}
     }
   }
   

     template<typename T1, typename T2>
     CONST int pi2 = 1;
 
-    template CONST int pi2<int,int>;
-    template<typename T> CONST int pi2<T,int> = 2;
+    template CONST int pi2<int,int>; //expected-note {{instantiation first required here}}
+    // FIXME: this diagnostic should say partial specialization
+    template<typename T> CONST int pi2<T,int> = 2;  //expected-error {{explicit specialization of 'pi2' after instantiation}}
   }
 
 #ifndef PRECXX11

test/SemaTemplate/explicit-specialization-member.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify %s 
 template<typename T>
 struct X0 {
   typedef T* type;

 
   template<typename T>
   template<int N>
-  void Baz<T>::bar() { // expected-note {{couldn't infer template argument 'N'}}
+  void Baz<T>::bar() { // disable-expected-note {{couldn't infer template argument 'N'}}
   }
 
   // FIXME: We shouldn't try to match this against a prior declaration if
   // template parameter matching failed.
   template<typename T>
   void Baz<T>::bar<0>() { // expected-error {{cannot specialize a member of an unspecialized template}} \
-                          // expected-error {{no function template matches}}
+                          // expected-error {{within class scope}}
   }
 }
 
 namespace PR19340 {
 template<typename T> struct Helper {
-  template<int N> static void func(const T *m) {} // expected-note {{failed template argument deduction}}
+  template<int N> static void func(const T *m) {} // disable-expected-note {{failed template argument deduction}}
 };
 
 template<typename T> void Helper<T>::func<2>() {} // expected-error {{cannot specialize a member}} \
-                                                  // expected-error {{no function template matches}}
+                                                 // expected-error {{within class scope}}
 }

test/SemaTemplate/member-templates.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++1y
+// RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -emit-llvm-only %s
+// RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fdelayed-template-parsing %s -DDELAYED_TEMPLATE_PARSING
+// RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fms-extensions %s -DMS_EXTENSIONS
+// RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only -fdelayed-template-parsing -fms-extensions %s -DMS_EXTENSIONS -DDELAYED_TEMPLATE_PARSING
+
+
+
+namespace out_of_class_explicit_specialization_that_is_a_partial_spec_declaration {
+template<typename T> struct A {
+  template<typename U> struct B {};
+  template<typename U> struct B<U*> : B<U> { 
+    template<class V> struct C;
+    template<class V> struct C<V*> {  };
+  };
+};
+
+template<> template<> template<class V>
+struct A<int>::B<char*>::C<V*> {
+  typedef int type;
+};
+
+A<int>::B<int*>::C<char*>::type abc; //expected-error {{no type}}
+A<int>::B<char*>::C<char*>::type use_out_of_class_partial_spec;
+
+} // end ns
+
+namespace test_if_explicit_partial_specializations_are_used {
+template<typename T> struct A {
+  template<typename U> struct B {};
+  template<typename U> struct B<U*> : B<U> { 
+    template<class V> struct C { };
+  };
+};
+
+template<> template<typename U> struct A<int>::B<U*> {
+  typedef char type2;
+};
+
+template<> template<typename U> struct A<int>::B : B<U*> { 
+  typedef int type3; 
+};
+
+
+A<int>::B<char*>::type2 x1;
+A<int>::B<char>::type3 x2; 
+A<int>::B<char>::type2 x3; 
+
+A<char>::B<char>::type x4; //expected-error{{type}}
+namespace swap_order_of_primary_and_partial {
+template<typename T> struct A {
+  template<typename U> struct B {};
+  template<typename U> struct B<U*> : B<U> { 
+    template<class V> struct C { };
+  };
+};
+
+
+template<> template<typename U> struct A<int>::B : B<U*> { 
+  typedef int type3; 
+};
+
+template<> template<typename U> struct A<int>::B<U*> {
+  typedef char type2;
+};
+
+
+A<int>::B<char*>::type2 x1;
+A<int>::B<char>::type3 x2; 
+A<int>::B<char>::type2 x3; 
+
+A<char>::B<char>::type x4; //expected-error{{type}}
+
+}// end ns
+
+} // end ns
+
+
+namespace test_no_out_class_primary {
+template<typename T> struct A {
+  template<typename U> struct B { int in_primary; };
+  template<typename U> struct B<U***> {
+    int in_partial3;
+  };
+};
+
+template<> template<typename U> struct A<int>::B<U*> {
+  int out_int_partial1;
+};
+
+template<> template<typename U> struct A<int>::B<U**> {
+  int out_int_partial2;
+};
+
+template<class T> template<class U> struct A<T>::B<U****> {
+  int out_partial4;
+};
+//int x0 = A<int>::B<char>().out_int_primary;
+int x0 = A<int>::B<char>().in_primary;
+int x1 = A<int>::B<char*>().out_int_partial1;
+int x2 = A<int>::B<char**>().out_int_partial2;
+int x3 = A<int>::B<char***>().in_partial3;
+int x4 = A<int>::B<char****>().out_partial4;
+}
+
+
+namespace test_out_class_primary_106_102 {
+template<typename T> struct A {
+  template<typename U> struct B { int in_primary; };
+  template<typename U> struct B<U***> {
+    int in_partial3;
+  };
+};
+
+template<> template<typename U> struct A<int>::B {
+  int out_int_primary;
+};
+template<> template<typename U> struct A<int>::B<U*> {
+  int out_int_partial1;
+};
+
+template<> template<typename U> struct A<int>::B<U**> {
+  int out_int_partial2;
+};
+
+template<class T> template<class U> struct A<T>::B<U****> {
+  int out_partial4;
+};
+int x0 = A<int>::B<char>().out_int_primary;
+int x1 = A<int>::B<char*>().out_int_partial1;
+int x2 = A<int>::B<char**>().out_int_partial2;
+int x3 = A<int>::B<char***>().out_int_partial2;
+int x4 = A<int>::B<char****>().out_int_partial2;
+namespace try_char_instead_of_int {
+int x0 = A<char>::B<char>().in_primary;
+int x1 = A<char>::B<char*>().in_primary;
+int x2 = A<char>::B<char**>().in_primary;
+int x3 = A<char>::B<char***>().in_partial3;
+int x4 = A<char>::B<char****>().out_partial4;
+
+} //end inner ns
+}
+
+
+namespace test_out_class_primary_swap_order_106 {
+template<typename T> struct A {
+  template<typename U> struct B { int in_primary; };
+  template<typename U> struct B<U***> {
+    int in_partial3;
+  };
+};
+
+template<> template<typename U> struct A<int>::B<U*> {
+  int out_int_partial1;
+};
+
+
+template<> template<typename U> struct A<int>::B {
+  int out_int_primary;
+};
+
+template<> template<typename U> struct A<int>::B<U**> {
+  int out_int_partial2;
+};
+
+template<class T> template<class U> struct A<T>::B<U****> {
+  int out_partial4;
+};
+int x0 = A<int>::B<char>().out_int_primary;
+int x1 = A<int>::B<char*>().out_int_partial1;
+int x2 = A<int>::B<char**>().out_int_partial2;
+int x3 = A<int>::B<char***>().out_int_partial2;
+int x4 = A<int>::B<char****>().out_int_partial2;
+
+namespace try_char_instead_of_int {
+int x0 = A<char>::B<char>().in_primary;
+int x1 = A<char>::B<char*>().in_primary;
+int x2 = A<char>::B<char**>().in_primary;
+int x3 = A<char>::B<char***>().in_partial3;
+int x4 = A<char>::B<char****>().out_partial4;
+
+} //end inner ns
+}
+
+namespace test_nested_member_partial_specs_3deep_180 {
+template<class> struct X {
+    template<class> struct Y {
+      template<int,class> struct Z {
+        int l;
+      };
+      template<int Dummy> struct Z<Dummy,int> {
+        int k;
+      };
+    };
+  };
+  
+  template<class T>
+  template<class U>
+  template<int N>
+  struct X<T>::Y<U>::Z<N, char*> { 
+    int j;
+  };
+  
+  template<>template<>
+  template<int N>
+  struct X<int>::Y<char>::Z<N, char> { 
+    int i;
+  };
+  
+  void a()
+  {
+    int x = X<int>::Y<int>::Z<0,int>().k;
+    x = X<int>::Y<char>::Z<0,int>().k;
+  x = X<int>::Y<char>::Z<0,char>().i;
+  x = X<int>::Y<char>::Z<0,char*>().j;
+  
+  }
+} // end ns
+
+
+namespace test_nested_member_partial_specs_3deep_180_swap_order1 {
+  template<class> struct X {
+    template<class> struct Y {
+      template<int,class> struct Z {
+    int l;
+    };
+      template<int Dummy> struct Z<Dummy,int> {
+      int k;
+    };
+    };
+  };
+  
+  template<>template<>
+  template<int N>
+  struct X<int>::Y<char>::Z<N, char> { 
+    int i;
+  };
+  
+  template<class T>
+  template<class U>
+  template<int N>
+  struct X<T>::Y<U>::Z<N, char*> { 
+    int j;
+  };
+  
+  void a()
+  {
+    int x = X<int>::Y<int>::Z<0,int>().k;
+    x = X<int>::Y<char>::Z<0,int>().k;
+  x = X<int>::Y<char>::Z<0,char>().i;
+  x = X<int>::Y<char>::Z<0,char*>().j;
+  
+  }
+} // end ns
+
+namespace test_no_instantiation_of_partial_specs_if_primary_is_specialized {
+
+template<class T> struct O {
+  template<class U1, class U2> struct L;
+  //template<class U1> struct L<typename T::type, U1*> { int k; };
+};
+
+
+struct HasType { typedef HasType* type; };
+struct HasNoType { };
+
+template<class T> template<class U1>
+struct O<T>::L<U1*, typename T::type> { int k; };
+
+
+template<> template<class, class> 
+struct O<HasNoType>::L {
+  int j;
+};
+
+int x0 = O<HasNoType>::L<HasNoType*, HasNoType*>().j; 
+int x1 = O<HasType>::L<HasType*, HasType*>().k;
+}
+
+
+namespace test_no_instantiation_of_partial_specs_if_primary_is_specialized_2 {
+
+template<class T> struct O {
+  template<class U1, class U2> struct L;
+  template<class U1> struct L<typename T::type, U1*> { int k; };
+};
+
+
+struct HasType { typedef HasType* type; };
+struct HasNoType { };
+
+
+//template<> template<class U1>
+//struct O<HasNoType>::L<U1*, U1*> { int j; };
+
+template<class T> template<class U1>
+struct O<T>::L<U1*, typename T::type> { int k; };
+
+template<> template<class U1> 
+struct O<HasNoType>::L<U1*, U1*> {
+  int l;
+};
+
+template<> template<class, class> 
+struct O<HasNoType>::L {
+  int j;
+};
+
+
+//template<class T> 
+//template<class U1> 
+//struct O<T>::L<U1*, typename T::type> { int k; };
+
+//template<> template<class U1, class U2>
+//struct O<HasNoType>::L { int j; };
+
+int x0 = O<HasNoType>::L<HasNoType*, HasNoType*>().l; 
+int x1 = O<HasNoType>::L<HasNoType*, HasType*>().j; 
+
+}
+
+namespace test_select_explicitly_specialized_partial_member_specs_if_ambiguous_317 {
+
+template<class T> struct O {
+  template<class U1, class U2> struct L;
+  template<class U1> struct L<U1*, typename U1::type> { int k; };
+};
+
+
+struct HasType { typedef HasType* type; };
+struct HasNoType { };
+
+
+template<> template<class U1>
+struct O<HasNoType>::L<U1*, U1*> { int j; };
+
+template<class T> template<class U2>
+struct O<T>::L<typename U2::type, U2*> { int k; };
+
+template<> template<class U1> 
+struct O<HasType>::L<U1*, U1*> {
+  int l;
+};
+
+template<> template<class, class> 
+struct O<HasNoType>::L {
+  int m;
+};
+
+
+//template<class T> 
+//template<class U1> 
+//struct O<T>::L<U1*, typename T::type> { int k; };
+
+//template<> template<class U1, class U2>
+//struct O<HasNoType>::L { int j; };
+
+int x0 = O<HasNoType>::L<HasNoType*, HasNoType*>().j; 
+int x1 = O<HasNoType>::L<HasNoType*, HasType*>().m; 
+
+}
+
+
+namespace test_similar_partial_specs_if_but_use_explicit_specialized_359 {
+
+template<class T> struct O {
+  template<class U1, class U2> struct L { int p; };
+  template<class U1> struct L<typename U1::type, U1*> { int k; };
+};
+
+
+struct HasType { typedef HasType* type; };
+struct HasNoType { };
+
+
+//template<> template<class U1>
+//struct O<HasNoType>::L<U1*, U1*> { int j; };
+
+template<class T> template<class U2>
+struct O<T>::L<U2*, typename U2::type> { int k2; };
+
+template<> template<class U1> 
+struct O<HasType>::L<U1*, U1*> {
+  int j;
+};
+
+
+//template<class T> 
+//template<class U1> 
+//struct O<T>::L<U1*, typename T::type> { int k; };
+
+//template<> template<class U1, class U2>
+//struct O<HasNoType>::L { int j; };
+
+int x0 = O<HasType>::L<HasType*, HasType*>().j; 
+int x1 = O<HasType>::L<HasNoType*, HasType*>().p;
+int x2 = O<HasType>::L<HasType*, HasNoType*>().p;
+}
+
+namespace check_redefinitions {
+
+namespace ns1 {
+
+template<class T> struct O {
+  template<class U> struct L;
+  template<class U1> struct L<U1*> { int k; }; //expected-note{{previous definition}}
+};
+
+template<class T> template<class U> 
+struct O<T>::L<U*> { //expected-error{{redefinition}}
+  int k;  
+};
+
+} // end ns
+
+
+namespace ns2 {
+
+template<class T> struct O {
+  template<class U> struct L;
+  template<class U1> struct L<U1*> { int k; }; 
+};
+
+template<>
+template<class V> 
+struct O<int>::L<V*> { //expected-note{{previous}}
+
+};
+template<> 
+template<class U> 
+struct O<int>::L<U*> { //expected-error{{redefinition}} 
+  int k;  
+};
+
+} // end ns
+
+} // end ns check_redefinitions
+
+
+namespace TEST_PARTIAL_SPECS_434 {
+template<class T> struct A {
+  template<class U> struct B {
+    U* u1;
+  };
+  template<class U1, class U2> struct C {
+    U1 *u1;
+    U2 *u2;
+  };
+};
+
+template<>
+template<class U> 
+struct A<int>::B<U*>;
+template<>
+template<class U> 
+struct A<int>::B<U*> {
+  U* u2;
+};
+template<>
+template<class U> 
+struct A<int>::B<U*>;
+
+template<class T>
+template<class U> 
+struct A<T>::B<U*>;
+template<class T>
+template<class U> 
+struct A<T>::B<U*> {
+  U* u3;
+};
+template<class T>
+template<class U> 
+struct A<T>::B<U*>;
+
+template<class T>
+template<class U> 
+struct A<T>::B<U**> {
+  U* u4;
+};
+
+template<>
+template<class U> 
+struct A<int>::B<U***> {
+  U* u5;
+};
+char *x1 = A<int>::B<char***>{}.u5;
+char *x2 = A<int>::B<char*>{}.u2;
+char *x3 = A<int>::B<char**>{}.u4;
+
+template<class T> 
+template<class U1> 
+struct A<T>::C<U1,T> {
+  U1 *u3;
+};
+
+template<class T> 
+template<class U1> 
+struct A<T>::C<U1,typename T::type> {
+  U1 *u4;
+};
+
+char *x4 = A<int>::C<char, int>{}.u3;
+struct HasType {
+  using type = int;
+};
+char *x5 = A<HasType>::C<char, int>{}.u4;
+
+template<class T> template<class U> 
+struct A<T>::B<U&>;
+
+template<class T> template<class U> 
+struct A<T>::B<U&> { };
+
+template<> template<class U>
+struct A<float>::B {
+  U* u510;
+};
+
+template<> template<class U>
+struct A<float>::B<U*> {
+  U* u515;
+};
+char ***x6 = A<float>::B<char***>{}.u515;
+
+}
+
+
+namespace variable_template_tests {
+
+namespace ns1 {
+template<class, class, int> struct X { };
+
+template<class T>
+struct A {
+  template<class U> 
+    static X<T, U, 0> u1;      
+};
+
+template<class T>
+template<class U>
+X<T, U*, 1> A<T>::u1<U*> = X<T, U*, 1>{};
+
+template<class T>
+template<class U>
+X<T, U**, 458> A<T>::u1<U**> = X<T, U**, 458>{};
+
+template<>
+template<class U>
+X<short, U, 462> A<short>::u1 = X<short, U, 462>{};
+
+template<>
+template<class U>
+X<short, U*, 466> A<short>::u1<U*> = X<short, U*, 466>{};
+
+template<>
+template<class U>
+X<float, U*, 2> A<float>::u1<U*> = X<float, U*, 2>{};
+
+template<class T>
+template<class U>
+X<T, U, 0> A<T>::u1 = X<T, U, 0>{};
+
+X<int, char*, 1> a1 = A<int>::u1<char *>;
+// choose the explicitly specialized partial specialization template
+X<float, char*, 2> a2 = A<float>::u1<char *>;
+X<short, char, 462> a479 = A<short>::u1<char>;
+X<short, char*, 466> a480 = A<short>::u1<char*>;
+X<short, char**, 466> a481 = A<short>::u1<char**>;
+X<float, char**, 458> a482 = A<float>::u1<char**>;
+X<int, char*, 1> a483 = A<int>::u1<char*>;
+}
+
+namespace test_52_fv {
+template<class, class, int> struct X { };
+
+template<class T>
+struct A {
+  template<class U> 
+    static constexpr X<T, U, 0> u1 = X<T, U, 0>{};    
+  auto f() { return u1<T>; }
+};
+
+template<> template<class U>
+constexpr X<float, U, 1> A<float>::u1 = X<float, U, 1>{};
+template<class T> template<class U>
+constexpr X<T, U*, 0> A<T>::u1<U*> = X<T, U*, 0>{};
+
+
+template<> template<class U>
+constexpr X<float, U**, 2> A<float>::u1<U**> = X<float, U**, 2>{};
+
+
+X<float, int, 1> x65 = A<float>::u1<int>;
+X<float, int*, 1> x65_1 = A<float>::u1<int*>;
+
+X<float, int**, 2> x65_2 = A<float>::u1<int**>;
+
+
+X<short, int, 0> x67 = A<short>::u1<int>;
+
+X<float, float, 1> x70 = A<float>{}.f();
+}
+
+
+namespace test_explicit_spec_of_var_template {
+template<class, class, int> struct X { };
+
+template<class T>
+struct A {
+  template<class U> 
+    static constexpr X<T, U, 0> u1 = X<T, U, 0>{};    
+  template<class U>
+    static constexpr X<T, U*, 0> u1<U*> = X<T, U*, 0>{};  
+};
+
+template<> template<class U>
+constexpr X<float, U, 1> A<float>::u1 = X<float, U, 1>{};
+
+template<class T> template<class U>
+constexpr X<T, U*, 0> A<T>::u1<U*>;
+template<> template<class U>
+constexpr X<char, U*, 1> A<char>::u1<U*> = X<char, U*, 1>{}; 
+
+
+template<class T> template<class U>
+constexpr X<T, U**, 104> A<T>::u1<U**> = X<T, U**, 104>{};
+
+
+template<> template<class U>
+constexpr X<float, U**, 2> A<float>::u1<U**> = X<float, U**, 2>{};
+
+
+X<float, int, 1> x65 = A<float>::u1<int>;
+X<float, int*, 1> x65_1 = A<float>::u1<int*>;
+
+X<float, int**, 2> x65_2 = A<float>::u1<int**>;
+X<char, int*, 1> x110 = A<char>::u1<int*>;
+X<char, int**, 104> x116 = A<char>::u1<int**>;
+}
+
+namespace ns641_variable_templates {
+template<class, class, int> struct X { int n; X(int n) : n(n) { } };
+
+template<class T>
+struct A {
+  template<class U> 
+    static X<T, U, 0> u1;    
+  
+  using ptrtype = decltype(u1<T*>); //expected-note{{required here}}
+  
+  ptrtype foo() const { return u1<T*>; }
+};
+
+template<> template<class U>
+X<float, U*, 0> A<float>::u1 = X<float, U*, 0>{2};   //expected-error{{after instantiation}}
+
+
+}
+
+}
+
+namespace vt_use_primary_template_before_explicit_specialization {
+namespace ns1 {
+template<class T>
+struct A {
+  template<class U> 
+    static constexpr int u1 = 1;    
+     
+  int arr[u1<T*>]; //expected-note{{required here}}
+};
+
+template<> template<class U>
+constexpr int A<short>::u1 = 2; //expected-error{{after instantiation}}
+} //end ns1
+
+namespace ns2 {
+
+template<class T>
+struct A {
+  template<class U> 
+    static constexpr int u1 = 1;    
+  template<class U> 
+    static constexpr double u1<U*> = 10;    
+  
+  decltype(u1<T*>) member;  //expected-note{{required here}}
+};
+
+template<> template<class U>
+constexpr int A<short>::u1 = 2; //expected-error{{after instantiation}}
+
+}
+
+
+namespace ns3 {
+template<class T>
+struct A {
+  template<class U> 
+    static constexpr int u1 = 1;    
+  template<class U> 
+    static constexpr int u1<U*> = 10;    
+  
+  //decltype(u1<T*>) member;
+  decltype(u1<T>) member2;  
+};
+
+template<> template<class U>
+constexpr int A<short>::u1 = 2; 
+
+}
+
+namespace specialize_with_same_type {
+
+template<class T>
+struct A {
+  template<class U> 
+    static T u1;    
+
+  decltype(u1<T>) member2;  
+
+};
+template<class T> template<class U>
+T A<T>::u1 = 1;
+
+template<> template<class U>
+short A<short>::u1 = 2;  // this is ok because same type
+}
+
+namespace specialize_with_same_template_type {
+template<class, class> struct X { };
+
+template<class T>
+struct A {
+  template<class U> 
+    static X<T, U> u1;    
+  decltype(u1<T*>) member2;  
+};
+
+template<class T> template<class U>
+X<T, U> A<T>::u1 = X<T, U>{};
+
+//template<class T> template<class U>
+//X<T, U*> A<T>::u1<U*> = X<T, U*>{};
+
+
+template<> template<class U>
+X<short, U> A<short>::u1 = X<short, U>{};  // this is ok because same type
+}
+}
+
+namespace variable_templates_713 {
+namespace auto_deduce_to_same_type {
+
+template<class T>
+struct A {
+  template<class U> 
+    static T u1;    
+  
+  decltype(u1<T>) member2;  //expected-note{{required here}}
+  
+};
+template<class T> template<class U>
+T A<T>::u1 = 1;
+
+template<> template<class U>
+auto A<int>::u1 = 2;
+
+template<> template<class U>
+auto A<short>::u1 = 2.0; //expected-error{{after instantiation}}
+
+} // end ns
+
+namespace auto_deduce_to_same_type2 {
+
+
+template<class T>
+struct A {
+  template<class U> 
+    static constexpr auto u1 = 1;    
+  
+  decltype(u1<T>) member2;  //expected-note{{required here}}
+  
+};
+
+template<> template<class U>
+constexpr auto A<int>::u1 = 3;
+
+template<> template<class U>
+constexpr auto A<double>::u1 = 3.0; //expected-error{{after instantiation}}
+
+namespace multiple_decls_and_lambda_as_member {
+
+template<class T>
+struct A {
+  template<class U, int N = 0> 
+    static int L;    
+};
+
+template<class T> template<class U, int N> 
+int A<T>::L = 0; 
+
+template<class T> template<class U>
+auto A<T>::L<U,0> = [](T *, U *u) { return  u; };
+
+char *pc = A<int>::L<char>((int *)0, (char*)0);
+}
+}
+
+namespace cannot_define_partial_specs_twice {
+
+template<class T>
+struct A {
+  template<class U> 
+    static constexpr U u1 = 1;    
+  template<class U> 
+    static constexpr U u1<U*> = 2;    
+};
+
+template<> template<class U>
+int A<short>::u1<U*>; //expected-note{{previous definition}}
+
+template<> template<class U>
+int A<short>::u1<U*> = 5;  //expected-error{{redefinition}}
+
+}
+
+}
+
+//--------------------------------EXPLICIT SPECIALIZATION--------------------
+namespace define_explicit_specs_inline_and_outline {
+
+template<class T> struct A {
+  template<class U> struct B;
+  template<> struct B<T>;
+};
+
+template<class T>
+template<>
+struct A<T>::B<T> { //expected-note{{matches}}
+  T* tb;
+};
+
+template<class T>
+template<>
+struct A<T>::B<char> { //expected-note{{matches}}
+  T* tb2;
+};
+
+int *x = A<int>::B<int>{}.tb;
+int *x1 = A<int>::B<char>{}.tb2;
+char *x2 = A<char>::B<char>{}.tb2; //expected-error{{ambiguous}}
+
+namespace check_sfinaeability_of_explicit_spec {
+template<class T> struct A {
+  template<class U> struct B {
+    T *tb0;
+    U *ub0;
+  };
+  template<> struct B<typename T::type>;
+};
+
+template<class T>
+template<>
+struct A<T>::B<typename T::type> { //expected-note{{matches}}
+  T* tb1;
+};
+
+template<class T>
+template<>
+struct A<T>::B<char> { //expected-note{{matches}}
+  T* tb2;
+};
+
+template<class T>
+struct HasType {
+   using type = T;
+};
+
+int *x = A<int>::B<int>{}.tb0;
+int *x1 = A<int>::B<char>{}.tb2;
+char *x2 = A<char>::B<char>{}.tb2; 
+
+HasType<int> *x3 = A<HasType<int>>::B<int>{}.tb1;
+HasType<int> *x4 = A<HasType<int>>::B<char>{}.tb2;
+HasType<char> *x5 = A<HasType<char>>::B<char>{}.tb2; //expected-error{{ambiguous}}
+
+} 
+namespace explicit_spec_3_deep_887 {
+
+template<class T> struct A {
+  template<class U> struct B;
+  template<> struct B<T>;
+};
+
+template<class T>
+template<>
+struct A<T>::B<T> { //expected-note{{matches}}
+  T* tb;
+  template<class V> struct C;
+};
+template<class T>
+template<>
+struct A<T>::B<char> { //expected-note{{matches}}
+  T* tb2;
+  template<int N> struct C;
+};
+template<class T> template<>
+struct A<T>::B<T>::C<T> {
+  T* tc1;
+};
+template<class T> template<>
+struct A<T>::B<T>::C<T*> {
+  T* tc1_912;
+};
+
+template<class T> template<>
+struct A<T>::B<char>::C<0> {
+  T* tc2;
+};
+
+
+template<class T> template<>
+struct A<T>::B<char>::C<10> {
+  T* tc3;
+};
+int *x1 = A<int>::B<int>::C<int>{}.tc1;
+int *x2 = A<int>::B<char>::C<0>{}.tc2;
+char *x3 = A<char>::B<char>{}; //expected-error{{ambiguous}}
+short *x4 = A<short>::B<char>::C<0>{}.tc2;
+short *x5 = A<short>::B<short>::C<short>{}.tc1;
+short *x6 = A<short>::B<short>::C<short*>{}.tc1_912;
+short *x7 = A<short>::B<char>::C<10>{}.tc3;
+
+}
+
+namespace partial_and_explicit_spec_3_deep_935 {
+
+template<class T> struct A {
+  template<class U> struct B;
+  template<> struct B<T>;
+};
+
+template<class T>
+template<>
+struct A<T>::B<T> { //expected-note{{matches}}
+  T* tb;
+  template<class V> struct C;
+};
+template<class T>
+template<>
+struct A<T>::B<T*> { 
+  T* tb1_951;
+  template<class V, int N> struct C { 
+    T* tc1_953;
+    V* vc1_954;
+  };
+};
+template<class T>
+template<class U>
+struct A<T>::B<U*> {
+  T* tb0_952;
+  U* ub0_952;
+  template<class V1, class V2> struct C;
+};
+
+template<class T>
+template<class U> template<>
+struct A<T>::B<U*>::C<T,U> {
+  T* tb1_967;
+  U* ub1_968;
+};
+
+template<class T>
+template<>
+struct A<T>::B<char> { //expected-note{{matches}}
+  T* tb2;
+  template<int N> struct C;
+};
+template<class T> template<>
+struct A<T>::B<T>::C<T> {
+  T* tc1;
+};
+template<class T> template<>
+struct A<T>::B<T>::C<T*> {
+  T* tc1_912;
+};
+
+template<class T> template<>
+struct A<T>::B<char>::C<0> {
+  T* tc2;
+};
+
+
+template<class T> template<>
+struct A<T>::B<char>::C<10> {
+  T* tc3;
+};
+int *x1 = A<int>::B<int>::C<int>{}.tc1;
+int *x2 = A<int>::B<char>::C<0>{}.tc2;
+char *x3 = A<char>::B<char>{}; //expected-error{{ambiguous}}
+short *x4 = A<short>::B<char>::C<0>{}.tc2;
+short *x5 = A<short>::B<short>::C<short>{}.tc1;
+short *x6 = A<short>::B<short>::C<short*>{}.tc1_912;
+short *x7 = A<short>::B<char>::C<10>{}.tc3;
+short *x8 = A<short>::B<char *>::C<short, char>{}.tb1_967;
+float *x9 = A<short>::B<short *>::C<float, 10>{}.vc1_954;
+
+
+}
+namespace member_function_templates_1009 {
+template<class T> struct A {
+  template<class U> struct B;
+};
+
+template<class T>
+template<>
+struct A<T>::B<T> {
+  T* tb;
+  template<class V> struct C;
+};
+
+template<class T>
+template<>
+struct A<T>::B<float> {
+  T* tb2;
+  
+  template<int N> struct C;
+};
+
+template<class T> template<>
+struct A<T>::B<T>::C<T> {
+  T* tc1;
+  template<class W> W* foo(W);
+  template<class W> T* foo(W*, T*) {
+    return nullptr;
+  }
+};
+
+template<class T> template<>
+struct A<T>::B<float>::C<0> {
+  T* tc2;
+  T* foo(T*) { return 0; } //expected-note{{parameter here}}
+};
+
+
+template<class T> template<>
+struct A<T>::B<float>::C<10> {
+  T* tc3;
+};
+
+template<class T> template<class W>
+W* A<T>::B<T>::C<T>::foo(W) { 
+  return (W*)(T*)nullptr; 
+}
+
+float *ip = A<char>::B<char>::C<char>{}.foo(3.2F);
+char *ip2 = A<char>::B<char>::C<char>{}.foo((float*)0, (char*)0);
+int *ip3 = A<int>::B<int>::C<int>{}.foo((float*)0, (int*)0);
+short *ip4 = A<short>::B<float>::C<0>{}.foo((float*)0); //expected-error{{float *}}
+
+}
+namespace nontemplate_parent_class_members {
+  struct A {
+    template<class U> struct B {
+      template<class V> struct C;
+    };
+  };
+  template<class U> template<> struct A::B<U>::C<int*> {
+    U* cu;
+  };
+  char *x = A::B<char>::C<int*>{}.cu;
+}
+namespace member_template_function_explicit_spec_1072 {
+template<class T> struct A {
+  template<class U> U* foo(U*, T*) { return 0; }
+};
+
+template<> template<class U>
+U* A<int>::foo(U*, int*) { return 0; }
+template<> template<>
+float* A<short>::foo(float*, short*) { return 0; }
+
+  
+}
+namespace member_template_function_explicit_spec_semantic_checking_1084 {
+template<class T> struct A {
+  template<class U> U* foo(U*, typename T::type *);
+
+  template<> int* foo(int*, typename T::type *) {  return 0; }
+};
+}
+
+namespace redefinition_explicit_member_template_func_1092 {
+
+template<class T, int N> struct A {
+  template<class U> U* foo(U*, T*);
+  template<class U> U* foo(U*, typename T::type *, const T (&a)[N], T*/*, X<N>*/);
+
+  template<> int *foo(int*, T*) { return 0; } //expected-note 2{{previous}}
+  template<> int *foo(int*, typename T::type *, const T (&)[N], T*) {  return 0; }
+  template<> int *foo(int*, T*) { return 0; } //expected-error{{redeclared}} \
+                                                expected-error{{redefinition}}
+
+};
+
+
+}
+
+namespace member_template_function_explicit_pack1 {
+template<class, class> struct X { };
+namespace type_pack {
+
+template<class ... Ts> struct A {
+  template<template<class, class> class UU> void bar(UU<Ts...>) { }
+  template<> void bar(X<Ts...>) { }
+};
+}
+namespace template_pack {
+
+template<class> struct W;
+template<class, class> struct X;
+
+template<template<template<class...> class SS, class S> class ... TTs> struct A {
+  
+  template<template<class...> class UU, class U> U* bar(TTs<UU, U> ... tts) { return 0; }
+  template<> int* bar(TTs<X,int> ...) { return 0; }
+  template<> char* bar(TTs<X,char> ...) { return 0; }
+  template<> char* bar(TTs<W,char> ...) { return 0; }
+  
+  template<template<class,class> class UU, class U> U* bar2(TTs<UU, U> ... tts) { return 0; } //expected-note{{substitution failure}}
+  template<> int* bar2(TTs<X,int> ...) { return 0; }
+  template<> char* bar2(TTs<X,char> ...) { return 0; }
+  template<> char* bar2(TTs<W,char> ...) { return 0; } //expected-error{{no function template matches}}
+  
+};
+
+}
+namespace nontype_args {
+template<int N> struct X { };
+
+template<class T, T N, int M, int O, char *P> struct A {
+
+  template<class U> U* foo(U (&)[O]) { return 0; } //expected-note{{failed template argument deduction}}
+  template<> float* foo(float (&)[O]) { return 0; }
+  template<> short* foo(short (&)[N]) { return 0; } //expected-error{{no function template matches}}
+
+  template<template<int> class UU> int bar(UU<M>) { return 0; } // 1
+  
+  template<template<int> class UU> int bar(UU<N>) { return 0; } // 2
+  // Matches 1
+  template<> int bar(X<N>) { return 0; }
+  // Matches 2
+  template<> int bar(X<M>) { return 0; }
+  
+  
+};
+namespace nontype_packs {
+
+template<int ... N> struct X { };
+template<int ... N> struct A {
+  template<template<int...> class UU> int foo(UU<N...>) { return 0; }
+  template<> int foo(X<N...>) { return 0; }  
+};
+
+namespace nested_types_1164 {
+
+template<class, int, int> struct X { };
+
+template<class T, int ... N> 
+struct A {
+  struct A1 {
+
+    template<class U> 
+    struct B {
+      struct B1 {
+        template<template<class, int...> class VV> int foo(VV<U, N...>, T*) { return 0; } //expected-note{{could not match}}
+        template<> int foo(X<U, N...>, T*) { return 0; }
+        template<> int foo(X<char, N...>, T*) { return 0; } //expected-error{{no function template matches}}
+        
+      };
+    };
+  };
+};
+} // end nested_types_1164
+
+namespace nested_types_1185 {
+
+template<int, int, class> struct X { };
+
+template<class T, int ... N> 
+struct A {
+  struct A1 {
+
+    template<class U> 
+    struct B {
+      struct B1 {
+        template<template<int, int, class> class VV> int foo(VV<N...>, T*, U**) { return 0; } 
+        template<> int foo(X<N...>, T*, U**) { return 0; } //expected-error{{no function template matches}}
+        
+      };
+    };
+  };
+};
+} // end nested_types_1185
+
+namespace check_template_template_param_nested {
+template<
+            template<class, class> class VV1, 
+            template<class, class> class VV2
+          > struct X { };
+template<class T> struct A {
+  struct A1 {
+  template<template<class, class> class ... UUs> 
+    struct B {
+      struct B1 {
+        template<
+          template<
+            template<class, class> class VV1, 
+            template<class, class> class VV2
+          > class VVV
+        > int foo(VVV<UUs...>) { return 0; }
+        template<> int foo(X<UUs...>) { return 0; }
+      };
+    };
+  };
+};
+
+namespace ns1 {
+template<
+            template<class, class> class VV1, 
+            template<class...> class VV2
+          > struct X { };
+template<class T> struct A {
+  struct A1 {
+  template<template<class, class> class ... UUs> 
+    struct B {
+      struct B1 {
+        template<
+          template<
+            template<class, class> class VV1, 
+            template<class...> class VV2
+          > class VVV
+        > int foo(VVV<UUs...>) { return 0; }
+        template<> int foo(X<UUs...>) { return 0; }
+      };
+    };
+  };
+};
+
+}
+
+namespace ns2 {
+template<
+            template<class, class> class VV1, 
+            template<class, class> class VV2
+          > struct X { };
+template<class T> struct A {
+  struct A1 {
+  template<template<class, class> class ... UUs> 
+    struct B {
+      struct B1 {
+        template<
+          template<
+            template<class, class> class VV1, 
+            template<class, class> class VV2
+          > class VVV
+        > int foo(VVV<UUs...>) { return 0; }
+        template<> int foo(X<UUs...>) { return 0; }
+      };
+    };
+  };
+};
+}
+
+namespace ns3 {
+#ifdef FIXME_1275
+// This should not be an error!
+template<
+            template<class, class> class VV1, 
+            template<class, class> class VV2
+          > struct X { };
+template<class T> struct A {
+  struct A1 {
+  template<template<class...> class ... UUs> 
+    struct B {
+      struct B1 {
+        template<
+          template<
+            template<class, class> class VV1, 
+            template<class, class> class VV2
+          > class VVV
+        > int foo(VVV<UUs...>) { return 0; }
+        template<> int foo(X<UUs...>) { return 0; }
+      };
+    };
+  };
+};
+#endif
+}
+
+
+} // end check_template_template_param_nested
+
+} // end ns nontype_packs
+} // end ns nontype_args
+} // end member_template_function_explicit_pack1
+
+namespace check_redefinition_errors_1307 {
+
+template<class T> struct A {
+  template<class V> V* foo(V*, T*) { return 0; }
+  template<> typename T::type* foo(typename T::type*, T*) //expected-note{{previous}}
+  { return (T*)0; }
+};
+
+template<class T> template<> 
+typename T::type* A<T>::foo(typename T::type*, T*) //expected-error{{redefinition}}
+{ return (T*)0; }
+
+namespace ns1_1319 {
+template<class T> struct A {
+  template<class V> V* foo(V*, T*) { return 0; }
+};
+
+template<class T> template<>
+char* A<T>::foo(char*, T*) { return (char*)(T*)0; }
+
+char *pc = A<int>{}.foo((char*)0, (int*)0);
+
+} // end ns1_1319
+} // end ns check_redefinition_errors_1307
+namespace ambiguous_explicit_specs_upon_substitution_1331 {
+  template<class T> struct A {
+  template<class V> V* foo(V*, T*) { return 0; } //expected-note{{ambiguous explicit specialization}}
+};
+
+
+template<class T> template<>
+char* A<T>::foo(char*, T*) { return (char*)(T*)0; }
+
+template<class T> template<>
+T* A<T>::foo(T*, T*) { return (T*)1; }
+
+
+
+char *pc = A<int>{}.foo((char*)0, (int*)0);
+char *pc2 = A<char>{}.foo((char*)0, (char*)0); //expected-error{{no matching}}
+
+} // end ns ambiguous_explicit_specs_upon_substitution_1331
+namespace explicitly_specialized_member_template_function_as_template {
+template<class T> struct A {
+  template<class V> constexpr int foo(V*, T*) { return 0; }
+};
+
+
+template<class T> template<>
+constexpr int A<T>::foo(char*, T*) { return 1; }
+
+template<class T> template<>
+constexpr int A<T>::foo(T*, T*) { return 2; }
+
+template<> template<class V>
+constexpr int A<float>::foo(V*, float*) { return 3; }
+
+template<> template<>
+constexpr int A<float>::foo(short*, float*) { return 4; }
+
+
+static_assert(A<int>{}.foo((char*)0, (int*)0) == 1, "");
+static_assert(A<short>{}.foo((short*)0, (short*)0) == 2, "");
+static_assert(A<float>{}.foo((char*)0, (float*)0) == 3, "");
+static_assert(A<float>{}.foo((short*)0, (float*)0) == 4, "");
+
+namespace ns1 {
+
+template<class T> struct A {
+  template<class V> constexpr int foo(T*) { return 0; } //expected-note{{ambiguous}}
+};
+
+template<class T> template<>
+constexpr int A<T>::foo<T>(T*) { return 1; }
+
+template<class T> template<>
+constexpr int A<T>::foo<float>(T*) { return 2; }
+
+template<> template<class V>
+constexpr int A<float>::foo(float*) { return 3; }
+
+template<> template<>
+constexpr int A<float>::foo<float>(float*) { return 4; }
+
+template<class T> template<>
+constexpr int A<T>::foo<char>(T*) { return 5; }
+
+template<> template<>
+constexpr int A<char>::foo<char>(char*) { return 6; }
+
+template<class T> template<>
+constexpr int A<T>::foo<long>(T*) { return 7; }
+
+
+static_assert(A<short>{}.foo<short>((short*)0) == 1, "");
+static_assert(A<short>{}.foo<float>((short*)0) == 2, "");
+static_assert(A<float>{}.foo<short>((float*)0) == 3, "");
+static_assert(A<float>{}.foo<short>((float*)0) == 3, "");
+static_assert(A<float>{}.foo<float>((float*)0) == 4, "");
+static_assert(A<short>{}.foo<char>((short*)0) == 5, "");
+static_assert(A<char>{}.foo<char>((char*)0) == 6, "");
+static_assert(A<char>{}.foo<long>((char*)0) == 7, "");
+static_assert(A<long>{}.foo<long>((char*)0) == 7, ""); //expected-error{{no matching}}
+
+} // end ns1
+
+namespace ns2 {
+
+template<class T> struct A {
+  template<class U> struct B {
+    template<class V> struct C {
+      template<class W1, class W2> constexpr int f(W1*, W2*, T*, U*, V*) { return 0; }
+      template<> constexpr int f(V*, V*, T*, U*, V*) { return 1; } //expected-note{{previous}}
+    };
+  };
+};
+template<class T> template<class U> template<class V> template<>
+constexpr int A<T>::B<U>::C<V>::f(T*, V*, T*, U*, V*) { return 2; }
+
+template<class T> template<class U> template<class V> template<>
+constexpr int A<T>::B<U>::C<V>::f(V*, V*, T*, U*, V*) { return 3; } //expected-error{{redefinition}}
+
+} // end ns2
+
+namespace ns3 {
+
+template<class T> struct A {
+  template<class U> struct B {
+    template<class V> struct C {
+      template<class W1, class W2> constexpr int f(W1*, W2*, T*, U*, V*) { return 0; } //expected-note{{ambiguous}}
+      template<> constexpr int f(V*, V*, T*, U*, V*) { return 1; } 
+    };
+  };
+};
+template<class T> template<class U> template<class V> template<>
+constexpr int A<T>::B<U>::C<V>::f(T*, V*, T*, U*, V*) { return 2; }
+
+constexpr int *ip = 0;
+constexpr char *cp = 0;
+constexpr float *fp = 0;
+constexpr short *sp = 0;
+
+static_assert(A<int>::B<char>::C<short>{}.f(sp, sp, ip, cp, sp) == 1, ""); 
+static_assert(A<int>::B<char>::C<short>{}.f(ip, sp, ip, cp, sp) == 2, ""); 
+static_assert(A<int>::B<char>::C<short>{}.f(ip, ip, ip, cp, sp) == 0, ""); 
+static_assert(A<int>::B<int>::C<int>{}.f(ip, ip, ip, ip, ip) == 0, ""); //expected-error{{no matching}}
+
+} // end ns3
+}
+} // end ns define_explicit_specs_inline_and_outline
+
+namespace 
+member_var_templates_explicit_specializations_at_class_scope_1458 {
+
+namespace ns1 {
+template<class T> struct A {
+  template<class W> static constexpr T var = 1;
+  template<class W> static constexpr T var<W*> = 2;
+  template<> static constexpr T var<char> = 3;      
+};
+template<class T> template<class W>
+constexpr T A<T>::var;
+template<class T> template<class W>
+constexpr T A<T>::var<W*>;
+template<class T> template<>
+constexpr T A<T>::var<char>;
+
+template<> template<class W>
+constexpr int A<float>::var<W*> = 4;
+
+// disable the use of all other specializations for A<short>
+template<> template<class W>
+constexpr int A<short>::var = 5;
+
+
+template<> template<class W>
+constexpr int A<long>::var = 7;
+
+template<> template<class W>
+constexpr int A<long>::var<W*> = 6;
+
+
+template<> template<class W>
+constexpr int A<long>::var<W**> = 8;
+
+template<> template<>
+constexpr int A<long>::var<float**> = 9;
+
+
+template<> template<>
+constexpr int A<long>::var<float*> = 10;
+
+template<> template<>
+constexpr int A<long>::var<double*> = 11;
+
+
+static_assert(A<int>::var<char> == 3, "");
+static_assert(A<int>::var<short> == 1, "");
+static_assert(A<int>::var<short*> == 2, "");
+static_assert(A<float>::var<short> == 1, "");
+static_assert(A<float>::var<char> == 3, "");
+static_assert(A<float>::var<char*> == 4, "");
+static_assert(A<short>::var<short> == 5, "");
+static_assert(A<short>::var<char> == 5, "");
+static_assert(A<short>::var<char*> == 5, "");
+
+static_assert(A<long>::var<short> == 7, "");
+static_assert(A<long>::var<char*> == 6, "");
+static_assert(A<long>::var<char**> == 8, "");
+static_assert(A<long>::var<float**> == 9, "");
+static_assert(A<long>::var<float*> == 10, "");
+static_assert(A<long>::var<double*> == 11, "");
+
+
+
+
+
+}
+namespace ns2 {
+template<class T> struct A {
+  template<class U> struct B {
+    template<class V> struct C {
+      template<class W> static constexpr int var = 1;
+      template<> static constexpr int var<char> = 2;      
+    };
+  };
+};
+
+static_assert(A<int>::B<char>::C<float>::var<char> == 2, "");
+
+} // end ns2
+
+} // end var_templates_class_scope_...
+

test/SemaTemplate/ms-class-specialization-class-scope.cpp

 public:
   template<typename U> struct X { typedef int x; };
 
-  typename X<int>::x a; // expected-note {{implicit instantiation first required here}}
+  typename X<int>::x a; //expected-error{{no type named 'x'}}
 
-  template<> struct X<int>; // expected-error {{explicit specialization of 'X<int>' after instantiation}}
-  template<> struct X<char>; // expected-note {{forward declaration}}
+  template<> struct X<int> { }; 
+  template<> struct X<char> { }; 
 
-  typename X<char>::x b; // expected-error {{incomplete type 'B<float>::X<char>' named in nested name specifier}}
+  typename X<char>::x b; //expected-error{{no type named 'x'}}
 
   template<> struct X<double> {
     typedef int y;

 
   typename X<double>::y c;
 
-  template<> struct X<float> {}; // expected-note {{previous definition is here}}
-  template<> struct X<T> {}; // expected-error {{redefinition of 'X<float>'}}
+  template<> struct X<float> {}; // expected-note {{matches}}
+  template<> struct X<T> {}; // expected-note {{matches}}
 };
 
-B<float> b; // expected-note {{in instantiation of}}
+B<float> b; //expected-note {{in instantiation of}}
+B<float>::X<float> b2; //expected-error {{ambiguous}}
 No newline at end of file