Improve support for out-of-line definitions of nested templates and

their members, including member class template, member function
templates, and member classes and functions of member templates.

To actually parse the nested-name-specifiers that qualify the name of
an out-of-line definition of a member template, e.g.,

  template<typename X> template<typename Y>
  X Outer<X>::Inner1<Y>::foo(Y) {
    return X();
  }

we need to look for the template names (e.g., "Inner1") as a member of
the current instantiation (Outer<X>), even before we have entered the
scope of the current instantiation. Since we can't do this in general
(i.e., we should not be looking into all dependent
nested-name-specifiers as if they were the current instantiation), we
rely on the parser to tell us when it is parsing a declaration
specifier sequence, and, therefore, when we should consider the
current scope specifier to be a current instantiation.

Printing of complicated, dependent nested-name-specifiers may be
somewhat broken by this commit; I'll add tests for this issue and fix
the problem (if it still exists) in a subsequent commit.

llvm-svn: 80044

1 files changed, 14 insertions, 5 deletions

diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 9dfa96288cc..e0798f685ba 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -27,10 +27,19 @@ using namespace clang;
 /// passed to indicate the C++ scope in which the identifier will be
 /// found. 
 TemplateNameKind Sema::isTemplateName(const IdentifierInfo &II, Scope *S,
-                                      TemplateTy &TemplateResult,
-                                      const CXXScopeSpec *SS) {
-  NamedDecl *IIDecl = LookupParsedName(S, SS, &II, LookupOrdinaryName);
-
+                                      const CXXScopeSpec *SS,
+                                      bool EnteringContext,
+                                      TemplateTy &TemplateResult) {                                      
+  LookupResult Found = LookupParsedName(S, SS, &II, LookupOrdinaryName, 
+                                        false, false, SourceLocation(),
+                                        EnteringContext);
+  
+  // FIXME: Cope with ambiguous name-lookup results.
+  assert(!Found.isAmbiguous() && 
+         "Cannot handle template name-lookup ambiguities");
+  
+  NamedDecl *IIDecl = Found;
+  
   TemplateNameKind TNK = TNK_Non_template;
   TemplateDecl *Template = 0;
 
@@ -1116,7 +1125,7 @@ Sema::ActOnDependentTemplateName(SourceLocation TemplateKWLoc,
     // "template" keyword is now permitted). We follow the C++0x
     // rules, even in C++03 mode, retroactively applying the DR.
     TemplateTy Template;
-    TemplateNameKind TNK = isTemplateName(Name, 0, Template, &SS);
+    TemplateNameKind TNK = isTemplateName(Name, 0, &SS, false, Template);
     if (TNK == TNK_Non_template) {
       Diag(NameLoc, diag::err_template_kw_refers_to_non_template)
         << &Name;