Index: include/clang/AST/DeclTemplate.h
===================================================================
--- include/clang/AST/DeclTemplate.h
+++ include/clang/AST/DeclTemplate.h
@@ -1768,9 +1768,23 @@
   void setMemberSpecialization() {
     ClassTemplatePartialSpecializationDecl *First =
         cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
-    assert(First->InstantiatedFromMember.getPointer() &&
-           "Only member templates can be member template specializations");
-    return First->InstantiatedFromMember.setInt(true);
+
+    // Partial specializations marked as member specializations can only be
+    // declared out of line.
+    assert(!First->InstantiatedFromMember.getPointer() &&
+           "Since we only instantiate partial declarations "
+           "during selection of the most specialized partial specialization - "
+           "this should never be true!");
+
+    assert(First == this &&
+           "When partially specializing a member template out of class "
+           "this must be the first declaration");
+
+    assert(this->isOutOfLine() && "Partial specializations explicitly "
+                                  "specialized as member templates can only be "
+                                  "specified out of line");
+
+    First->InstantiatedFromMember.setInt(true);
   }
 
   /// Retrieves the injected specialization type for this partial
Index: include/clang/Sema/Sema.h
===================================================================
--- include/clang/Sema/Sema.h
+++ include/clang/Sema/Sema.h
@@ -6046,10 +6046,11 @@
   // C++ Template Instantiation
   //
 
-  MultiLevelTemplateArgumentList getTemplateInstantiationArgs(NamedDecl *D,
-                                     const TemplateArgumentList *Innermost = 0,
-                                                bool RelativeToPrimary = false,
-                                               const FunctionDecl *Pattern = 0);
+  MultiLevelTemplateArgumentList getTemplateInstantiationArgs(
+      NamedDecl *D, const TemplateArgumentList *Innermost = 0,
+      bool RelativeToPrimary = false, const FunctionDecl *Pattern = 0,
+      const ArrayRef<TemplateParameterList *> TPLsOfDeclBeingSubstituted =
+          ArrayRef<TemplateParameterList *>());
 
   /// \brief A template instantiation that is currently in progress.
   struct ActiveTemplateInstantiation {
Index: include/clang/Sema/Template.h
===================================================================
--- include/clang/Sema/Template.h
+++ include/clang/Sema/Template.h
@@ -371,12 +371,6 @@
     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
@@ -442,35 +436,16 @@
 
     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();
Index: lib/AST/DeclTemplate.cpp
===================================================================
--- lib/AST/DeclTemplate.cpp
+++ lib/AST/DeclTemplate.cpp
@@ -428,10 +428,12 @@
             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;
 }
 
@@ -855,6 +857,7 @@
   return Result;
 }
 
+
 //===----------------------------------------------------------------------===//
 // FriendTemplateDecl Implementation
 //===----------------------------------------------------------------------===//
Index: lib/Sema/SemaDecl.cpp
===================================================================
--- lib/Sema/SemaDecl.cpp
+++ lib/Sema/SemaDecl.cpp
@@ -3234,8 +3234,38 @@
   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.
Index: lib/Sema/SemaTemplate.cpp
===================================================================
--- lib/Sema/SemaTemplate.cpp
+++ lib/Sema/SemaTemplate.cpp
@@ -5878,15 +5878,19 @@
 
   return false;
 }
-
-DeclResult
-Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
-                                       TagUseKind TUK,
-                                       SourceLocation KWLoc,
-                                       SourceLocation ModulePrivateLoc,
-                                       TemplateIdAnnotation &TemplateId,
-                                       AttributeList *Attr,
-                               MultiTemplateParamsArg TemplateParameterLists) {
+unsigned getNumberOfEmptyTemplateParameterLists(
+    const ArrayRef<TemplateParameterList *> TemplateParameterLists) {
+  unsigned NumOfEmptyTPLs = 0;
+  for (const auto *CurTPL : TemplateParameterLists) {
+    if (!CurTPL->size())
+      ++NumOfEmptyTPLs;
+  }
+  return NumOfEmptyTPLs;    
+}
+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;
@@ -6122,8 +6126,23 @@
                                              TemplateParameterLists.data());
     }
 
-    if (!PrevPartial)
+    if (!PrevPartial) {
       ClassTemplate->AddPartialSpecialization(Partial, InsertPos);
+      // If this is an out of line partial specialization declaration that is
+      // first declared out of class, we might not have an instantiated-from
+      // member - but still need to mark this partial specialization as a
+      // 'member-specialization'.
+      //  For e.g.
+      //    template<class T> struct A {
+      //      template<class U> struct B { };
+      //    };
+      //    template<> template<class U> struct A<int>::B<U*> { }; <- mark
+      if (Partial->getDeclContext() != CurContext &&
+          getNumberOfEmptyTemplateParameterLists(TemplateParameterLists)) {
+        Partial->setLexicalDeclContext(CurContext);
+        Partial->setMemberSpecialization();
+      }
+    }
     Specialization = Partial;
 
     // If we are providing an explicit specialization of a member class
Index: lib/Sema/SemaTemplateDeduction.cpp
===================================================================
--- lib/Sema/SemaTemplateDeduction.cpp
+++ lib/Sema/SemaTemplateDeduction.cpp
@@ -4633,9 +4633,52 @@
     Better2 = !::FinishTemplateArgumentDeduction(
         *this, 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) {
+    // FIXME: Once this is moved to either Sema or Context, call it from there.
+    unsigned getNumberOfEmptyTemplateParameterLists(const Decl *D);
 
-  if (Better1 == Better2)
-    return 0;
+    auto GetPrototypePartialSpecialization = [](ClassTemplatePartialSpecializationDecl *D) {
+      ClassTemplatePartialSpecializationDecl *It = D;
+      while (It->getInstantiatedFromMember()) {
+        if (It->isMemberSpecialization())
+          return It;
+        It = It->getInstantiatedFromMember();
+      }
+      return It;
+    };
+    unsigned NumOfEmptyTPLSin1 = getNumberOfEmptyTemplateParameterLists(
+        GetPrototypePartialSpecialization(PS1));
+    unsigned NumOfEmptyTPLSin2 = getNumberOfEmptyTemplateParameterLists(
+        GetPrototypePartialSpecialization(PS2));
+    if (NumOfEmptyTPLSin1 == NumOfEmptyTPLSin2)
+      return 0;
+    else 
+      return (NumOfEmptyTPLSin1 > NumOfEmptyTPLSin2) ? PS1 : PS2;
+  }
 
   return Better1 ? PS1 : PS2;
 }
Index: lib/Sema/SemaTemplateInstantiate.cpp
===================================================================
--- lib/Sema/SemaTemplateInstantiate.cpp
+++ lib/Sema/SemaTemplateInstantiate.cpp
@@ -31,6 +31,10 @@
 // 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.
 ///
@@ -48,20 +52,30 @@
 /// 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;
 
+  // The index of the outer decl context.  '0' is the current innermost
+  // DeclContext.  It is used to calculate the index within
+  // TPLsOfDeclBeingSubstituted if supplied.
+  unsigned OuterDeclContextIndex = 0;
   if (Innermost)
     Result.addOuterTemplateArguments(Innermost);
   
   DeclContext *Ctx = dyn_cast<DeclContext>(D);
   if (!Ctx) {
     Ctx = D->getDeclContext();
+    ++OuterDeclContextIndex;
 
     // Add template arguments from a variable template instantiation.
     if (VarTemplateSpecializationDecl *Spec =
@@ -104,27 +118,49 @@
         return Result;
       }
     }
-  }
-  
+  } 
+
   while (!Ctx->isFileContext()) {
+    TemplateParameterList *const CurTPL = [&] {
+      const int NumberOfTPLsOfDeclBeingSubstituted =
+          TPLsOfDeclBeingSubstituted.size();
+      const int CurTPLIndex =
+          NumberOfTPLsOfDeclBeingSubstituted
+              ? NumberOfTPLsOfDeclBeingSubstituted - 1 - OuterDeclContextIndex
+              : -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)) ||
+          (CurTPL && CurTPL->size() == 0)) {
+        // 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
+        //
         break;
-
+      }
       Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs());
-      
-      // If this class template specialization was instantiated from a 
+      // 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;
-    }
-    // Add template arguments from a function template specialization.
-    else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Ctx)) {
+    } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Ctx)) {
+      // Add template arguments from a function template specialization.
       if (!RelativeToPrimary &&
           (Function->getTemplateSpecializationKind() == 
                                                   TSK_ExplicitSpecialization &&
@@ -169,19 +205,20 @@
         const TemplateSpecializationType *TST =
             cast<TemplateSpecializationType>(Context.getCanonicalType(T));
         Result.addOuterTemplateArguments(
-            llvm::makeArrayRef(TST->getArgs(), TST->getNumArgs()));
+              llvm::makeArrayRef(TST->getArgs(), TST->getNumArgs()));
         if (ClassTemplate->isMemberSpecialization())
           break;
       }
     }
-
     Ctx = Ctx->getParent();
+    ++OuterDeclContextIndex;
     RelativeToPrimary = false;
   }
 
   return Result;
 }
 
+
 bool Sema::ActiveTemplateInstantiation::isInstantiationRecord() const {
   switch (Kind) {
   case TemplateInstantiation:
@@ -1971,8 +2008,11 @@
       Instantiation->setInvalidDecl();
       continue;
     }
+    // Do not eagerly transform partial specialization declarations.
+    Decl *NewMember = nullptr;
+    if (!isa<ClassTemplatePartialSpecializationDecl>(Member)) 
+      NewMember = Instantiator.Visit(Member);
 
-    Decl *NewMember = Instantiator.Visit(Member);
     if (NewMember) {
       if (FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) {
         Fields.push_back(Field);
@@ -2077,20 +2117,7 @@
   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
@@ -2190,6 +2217,203 @@
   };
 }
 
+
+
+SmallVector<TemplateParameterList *, 4>
+getTemplateParameterListsOfDeclaration(const Decl *D) {
+  SmallVector<TemplateParameterList *, 4> TPLs;
+  const TagDecl *PatternDecl = 0;
+  TemplateParameterList *InnerMostTPL = 0;
+  
+  // Separate out the innermost TPL from the pattern - since the pattern is a
+  // CXXRecordDecl which captures the TPLs the template was declared with,
+  // and can be used to extract out all the template parameter lists.
+
+  if (auto *CTD = dyn_cast<ClassTemplateDecl>(D)) {
+    InnerMostTPL = CTD->getTemplateParameters();
+    PatternDecl = CTD->getTemplatedDecl();
+  } else if (auto *PTSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
+    InnerMostTPL = PTSD->getTemplateParameters();
+    PatternDecl = PTSD;
+  } else if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
+    if (CTSD->isExplicitSpecialization()) {
+      // If this was declared as an explicit specialization, all the TPLs
+      // are included in the getTemplateParameterList(i) info...
+      InnerMostTPL = 0; 
+      PatternDecl = CTSD;
+    } else {
+      CTSD->dump();
+      llvm_unreachable("A pattern declaration can not be a non-explicit "
+                       "ClassTemplateSpecializationDecl");
+    }
+  } else if (auto *RD = dyn_cast<CXXRecordDecl>(D)) {
+    if (ClassTemplateDecl *CTD = RD->getDescribedClassTemplate()) {
+      PatternDecl = RD;
+      InnerMostTPL = CTD->getTemplateParameters();
+    }
+  } else {
+    D->dump();
+    llvm_unreachable("Not implemented for all (function/variable) template "
+                    "declarations yet!");
+  }
+
+  // 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 (ParentDC->isRecord()) {
+        if (isa<CXXRecordDecl>(ParentDC)) {
+          auto ParentTPLs = getTemplateParameterListsOfDeclaration(
+              dyn_cast<CXXRecordDecl>(ParentDC));
+          TPLs.append(ParentTPLs.begin(), ParentTPLs.end());
+        }
+      }
+    } else {  // For out of line declarations use the PatternDecl.
+      for (unsigned I = 0; I != PatternDecl->getNumTemplateParameterLists();
+           ++I) 
+        TPLs.push_back(PatternDecl->getTemplateParameterList(I));
+    }
+    if (InnerMostTPL)
+      TPLs.push_back(InnerMostTPL);
+  }
+  return TPLs;
+}
+// FIXME: Where should this function go? Sema? Context?
+unsigned getNumberOfEmptyTemplateParameterLists(const Decl *D) {
+  unsigned num = 0;
+  for (auto *tpl : getTemplateParameterListsOfDeclaration(D)) {
+    if (!tpl->size())
+      ++num;
+  }
+  return num;
+}
+
+namespace {
+
+ 
+class ClassTemplatePartialSpecializationFinder {
+  Sema &SemaRef;
+  ClassTemplateDecl *const TemplateBeingInstantiated;
+  CXXRecordDecl *const ParentClassOfTemplateBeingInstantiated;
+
+public:
+  typedef SmallVector<ClassTemplatePartialSpecializationDecl *, 8> SpecVectorTy;
+ 
+  // Iterate through all Ancestor templates and find all partial
+  // specializations from each one.
+ 
+  SpecVectorTy getAllPartialSpecializationsFromAncestorTemplates() const {
+
+    SmallVector<ClassTemplatePartialSpecializationDecl *, 8> AllPartialSpecs;
+    ClassTemplateDecl *ClassTemplateIt = TemplateBeingInstantiated;
+    while (ClassTemplateDecl *const AncestorClassTemplate =
+               ClassTemplateIt->getInstantiatedFromMemberTemplate()) {
+      SpecVectorTy PSpecs;
+
+      AncestorClassTemplate->getPartialSpecializations(PSpecs);
+      AllPartialSpecs.append(PSpecs.begin(), PSpecs.end());
+      ClassTemplateIt = AncestorClassTemplate;
+    }
+    return SpecVectorTy(AllPartialSpecs.begin(), AllPartialSpecs.end());
+  }
+  // Iterate through the specializations associated with all ancestor templates
+  //  - substitute the outer enclosing arguments of the nested TemplateBeingInstanted.
+  //  FIXME: If the template is not a member template this should just return
+  //    the list of partial specializations, right ...
+  SpecVectorTy getRelevantPartialSpecializationsFromAncestorTemplates(
+      SourceLocation PointOfInstantiation) const {
+    SpecVectorTy AllPartialSpecs =
+        getAllPartialSpecializationsFromAncestorTemplates();
+    SpecVectorTy RelevantPartialSpecs;
+    for (ClassTemplatePartialSpecializationDecl *const APSpec :
+         AllPartialSpecs) {
+
+      clang::MultiLevelTemplateArgumentList OuterTemplateArgs =
+          SemaRef.getTemplateInstantiationArgs(
+              TemplateBeingInstantiated, 0, false, 0);
+
+      Sema::InstantiatingTemplate Inst(SemaRef, PointOfInstantiation, APSpec);
+      // If we have exceeded the maximum recursion instantiation depth, return 
+      // an empty vector.
+      if (Inst.isInvalid())
+        return SpecVectorTy();
+        
+      // 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);
+
+      if (auto *CTPSD = cast_or_null<ClassTemplatePartialSpecializationDecl>(
+              DeclInstantiator.Visit(APSpec))) {
+        RelevantPartialSpecs.push_back(CTPSD);
+      }
+    }
+    return RelevantPartialSpecs;
+  }
+
+  ClassTemplatePartialSpecializationFinder(
+      Sema &S, ClassTemplateDecl *CurClassTemplate)
+      : SemaRef(S), TemplateBeingInstantiated(CurClassTemplate),
+        ParentClassOfTemplateBeingInstantiated(
+            isa<CXXRecordDecl>(CurClassTemplate->getDeclContext())
+                ? cast<CXXRecordDecl>(CurClassTemplate->getDeclContext())
+                      ->getCanonicalDecl()
+                : 0) {}
+
+  SpecVectorTy
+  getAllPartialSpecializationsFromWhichToSelectTheMostSpecializedTemplate(
+      SourceLocation POI) const {
+
+    SpecVectorTy 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()) {
+      SpecVectorTy APSpecs =
+          getRelevantPartialSpecializationsFromAncestorTemplates(
+              POI);
+      AllPartialSpecs.append(APSpecs.begin(), APSpecs.end());
+    }
+    return AllPartialSpecs;
+  }
+};
+
+}  // End anonymous namespace
+
 bool Sema::InstantiateClassTemplateSpecialization(
     SourceLocation PointOfInstantiation,
     ClassTemplateSpecializationDecl *ClassTemplateSpec,
@@ -2228,8 +2452,7 @@
     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
@@ -2238,10 +2461,16 @@
   //   matching the template arguments of the class template
   //   specialization with the template argument lists of the partial
   //   specializations.
+  SmallVector<ClassTemplatePartialSpecializationDecl *, 8> PartialSpecs =
+      ClassTemplatePartialSpecializationFinder(*this, Template)
+          .getAllPartialSpecializationsFromWhichToSelectTheMostSpecializedTemplate(
+              PointOfInstantiation);
+
+  CXXRecordDecl *Pattern = 0;
+
+  
   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];
@@ -2352,11 +2581,13 @@
     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;
 }
Index: lib/Sema/SemaTemplateInstantiateDecl.cpp
===================================================================
--- lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -959,18 +959,6 @@
   }
 
   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;
 }
 
@@ -2694,30 +2682,6 @@
                                                     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,
@@ -2738,10 +2702,6 @@
 
   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;
 }
 
Index: test/CXX/temp/temp.decls/temp.class.spec/p6.cpp
===================================================================
--- test/CXX/temp/temp.decls/temp.class.spec/p6.cpp
+++ test/CXX/temp/temp.decls/temp.class.spec/p6.cpp
@@ -37,13 +37,17 @@
 // 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*> {
Index: test/SemaTemplate/member-templates.cpp
===================================================================
--- test/SemaTemplate/member-templates.cpp
+++ test/SemaTemplate/member-templates.cpp
@@ -0,0 +1,519 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++1y
+
+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;
+
+}
\ No newline at end of file