diff --git a/lib/Sema/SemaAccess.cpp b/lib/Sema/SemaAccess.cpp
index a929896..4cfd99d 100644
--- a/lib/Sema/SemaAccess.cpp
+++ b/lib/Sema/SemaAccess.cpp
@@ -319,7 +319,7 @@
   if (Friend == FTD->getCanonicalDecl())
     return Sema::AR_accessible;
 
-  if (MightInstantiateTo(S, FTD, Friend))
+  if (EC.isDependent() && MightInstantiateTo(S, FTD, Friend))
     return Sema::AR_dependent;
 
   return Sema::AR_inaccessible;
diff --git a/lib/Sema/SemaTemplateInstantiateDecl.cpp b/lib/Sema/SemaTemplateInstantiateDecl.cpp
index cbd9086..d929b5a 100644
--- a/lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ b/lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -904,8 +904,15 @@
   // Check whether there is already a function template specialization for
   // this declaration.
   FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
+
+  bool isFriend;
+  if (FunctionTemplate)
+    isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
+  else
+    isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
+
   void *InsertPos = 0;
-  if (FunctionTemplate && !TemplateParams) {
+  if (!isFriend && FunctionTemplate && !TemplateParams) {
     llvm::FoldingSetNodeID ID;
     FunctionTemplateSpecializationInfo::Profile(ID,
                              TemplateArgs.getInnermost().getFlatArgumentList(),
@@ -933,14 +940,29 @@
     return 0;
   QualType T = TInfo->getType();
 
+  NestedNameSpecifier *Qualifier = D->getQualifier();
+  if (Qualifier) {
+    Qualifier = SemaRef.SubstNestedNameSpecifier(Qualifier,
+                                                 D->getQualifierRange(),
+                                                 TemplateArgs);
+    if (!Qualifier) return 0;
+  }
+
   // If we're instantiating a local function declaration, put the result
   // in the owner;  otherwise we need to find the instantiated context.
   DeclContext *DC;
   if (D->getDeclContext()->isFunctionOrMethod())
     DC = Owner;
-  else
+  else if (isFriend && Qualifier) {
+    CXXScopeSpec SS;
+    SS.setScopeRep(Qualifier);
+    SS.setRange(D->getQualifierRange());
+    DC = SemaRef.computeDeclContext(SS);
+    if (!DC) return 0;
+  } else {
     DC = SemaRef.FindInstantiatedContext(D->getLocation(), D->getDeclContext(), 
                                          TemplateArgs);
+  }
 
   FunctionDecl *Function =
       FunctionDecl::Create(SemaRef.Context, DC, D->getLocation(),
@@ -948,9 +970,8 @@
                            D->getStorageClass(),
                            D->isInlineSpecified(), D->hasWrittenPrototype());
 
-  // Substitute the nested name specifier, if any.
-  if (SubstQualifier(D, Function))
-    return 0;
+  if (Qualifier)
+    Function->setQualifierInfo(Qualifier, D->getQualifierRange());
 
   Function->setLexicalDeclContext(Owner);
 
@@ -974,7 +995,7 @@
     // which means substituting int for T, but leaving "f" as a friend function
     // template.
     // Build the function template itself.
-    FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, Owner,
+    FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, DC,
                                                     Function->getLocation(),
                                                     Function->getDeclName(),
                                                     TemplateParams, Function);
@@ -1016,9 +1037,7 @@
 
   // If the original function was part of a friend declaration,
   // inherit its namespace state and add it to the owner.
-  NamedDecl *FromFriendD 
-      = TemplateParams? cast<NamedDecl>(D->getDescribedFunctionTemplate()) : D;
-  if (FromFriendD->getFriendObjectKind()) {
+  if (isFriend) {
     NamedDecl *ToFriendD = 0;
     NamedDecl *PrevDecl;
     if (TemplateParams) {
@@ -1029,11 +1048,7 @@
       PrevDecl = Function->getPreviousDeclaration();
     }
     ToFriendD->setObjectOfFriendDecl(PrevDecl != NULL);
-    if (!Owner->isDependentContext() && !PrevDecl)
-      DC->makeDeclVisibleInContext(ToFriendD, /* Recoverable = */ false);
-
-    if (!TemplateParams)
-      Function->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
+    DC->makeDeclVisibleInContext(ToFriendD, /*Recoverable=*/ false);
   }
 
   return Function;
diff --git a/test/CXX/temp/temp.decls/temp.friend/p1.cpp b/test/CXX/temp/temp.decls/temp.friend/p1.cpp
index 3981802..0e41e5f 100644
--- a/test/CXX/temp/temp.decls/temp.friend/p1.cpp
+++ b/test/CXX/temp/temp.decls/temp.friend/p1.cpp
@@ -178,3 +178,16 @@
   };
   template class D<int>;
 }
+
+namespace test8 {
+  template <class N> class A {
+    static int x;
+    template <class T> friend void foo();
+  };
+  template class A<int>;
+
+  template <class T> void foo() {
+    A<int>::x = 0;
+  }
+  template void foo<int>();
+}