When a friend is declared in a dependent context, don't even try to

match it up with a declaration in the outer scope.

llvm-svn: 85628

clang/lib/Sema/SemaTemplate.cpp

@@ -613,11 +613,19 @@ Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
       SemanticContext = PrevDecl->getDeclContext();
     } else {
       // Declarations in outer scopes don't matter. However, the outermost
-      // context we computed is the semntic context for our new 
+      // context we computed is the semantic context for our new 
       // declaration.
       PrevDecl = 0;
       SemanticContext = OutermostContext;
     }
+    
+    if (CurContext->isDependentContext()) {
+      // If this is a dependent context, we don't want to link the friend
+      // class template to the template in scope, because that would perform
+      // checking of the template parameter lists that can't be performed
+      // until the outer context is instantiated.
+      PrevDecl = 0;
+    }
   } else if (PrevDecl && !isDeclInScope(PrevDecl, SemanticContext, S))
     PrevDecl = 0;
 

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

@@ -434,9 +434,10 @@ Decl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) {
   // Trigger creation of the type for the instantiation.
   SemaRef.Context.getTypeDeclType(RecordInst);
   
-  // We're done with friends now.
-  if (Inst->getFriendObjectKind())
+  // Finish handling of friends.
+  if (Inst->getFriendObjectKind()) {
     return Inst;
+  }
   
   Owner->addDecl(Inst);
   

clang/test/SemaTemplate/friend-template.cpp

@@ -72,3 +72,22 @@ class Foo {
 };
 
 Foo<int> foo;
+
+template<typename T, T Value>
+struct X2a;
+
+template<typename T, int Size>
+struct X2b;
+
+template<typename T>
+class X3 {
+  template<typename U, U Value>
+  friend struct X2a;
+
+  template<typename U, T Value>
+  friend struct X2b;
+};
+
+X3<int> x3i; // okay
+
+X3<long> x3l; // FIXME: should cause an instantiation-time failure