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.



git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@80044 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 48 insertions, 13 deletions

diff --git a/include/clang/Parse/Action.h b/include/clang/Parse/Action.h
index 50074cd771..3287e634eb 100644
--- a/include/clang/Parse/Action.h
+++ b/include/clang/Parse/Action.h
@@ -190,14 +190,28 @@ public:
   virtual bool isCurrentClassName(const IdentifierInfo &II, Scope *S,
                                   const CXXScopeSpec *SS = 0) = 0;
 
-  /// \brief Determines whether the identifier II is a template name
-  /// in the current scope. If so, the kind of template name is
-  /// returned, and \p TemplateDecl receives the declaration. An
-  /// optional CXXScope can be passed to indicate the C++ scope in
-  /// which the identifier will be found.
+  /// \brief Determine whether the given identifier refers to the name of a
+  /// template.
+  ///
+  /// \param II the identifier that we are querying to determine whether it
+  /// is a template.
+  ///
+  /// \param S the scope in which name lookup occurs
+  ///
+  /// \param SS the C++ scope specifier that precedes the template name, if
+  /// any.
+  ///
+  /// \param EnteringContext whether we are potentially entering the context
+  /// referred to by the scope specifier \p SS
+  ///
+  /// \param Template if the name does refer to a template, the declaration
+  /// of the template that the name refers to.
+  ///
+  /// \returns the kind of template that this name refers to.
   virtual TemplateNameKind isTemplateName(const IdentifierInfo &II, Scope *S,
-                                          TemplateTy &Template,
-                                          const CXXScopeSpec *SS = 0) = 0;
+                                          const CXXScopeSpec *SS,
+                                          bool EnteringContext,
+                                          TemplateTy &Template) = 0;
 
   /// ActOnCXXGlobalScopeSpecifier - Return the object that represents the
   /// global scope ('::').
@@ -216,7 +230,8 @@ public:
                                                   const CXXScopeSpec &SS,
                                                   SourceLocation IdLoc,
                                                   SourceLocation CCLoc,
-                                                  IdentifierInfo &II) {
+                                                  IdentifierInfo &II,
+                                                  bool EnteringContext) {
     return 0;
   }
 
@@ -1990,9 +2005,28 @@ public:
   virtual bool isCurrentClassName(const IdentifierInfo& II, Scope *S,
                                   const CXXScopeSpec *SS);
 
+  /// \brief Determine whether the given identifier refers to the name of a
+  /// template.
+  ///
+  /// \param II the identifier that we are querying to determine whether it
+  /// is a template.
+  ///
+  /// \param S the scope in which name lookup occurs
+  ///
+  /// \param SS the C++ scope specifier that precedes the template name, if
+  /// any.
+  ///
+  /// \param EnteringContext whether we are potentially entering the context
+  /// referred to by the scope specifier \p SS
+  ///
+  /// \param Template if the name does refer to a template, the declaration
+  /// of the template that the name refers to.
+  ///
+  /// \returns the kind of template that this name refers to.
   virtual TemplateNameKind isTemplateName(const IdentifierInfo &II, Scope *S,
-                                          TemplateTy &Template,
-                                          const CXXScopeSpec *SS = 0);
+                                          const CXXScopeSpec *SS,
+                                          bool EnteringContext,
+                                          TemplateTy &Template);
 
   /// ActOnDeclarator - If this is a typedef declarator, we modify the
   /// IdentifierInfo::FETokenInfo field to keep track of this fact, until S is
diff --git a/include/clang/Parse/Parser.h b/include/clang/Parse/Parser.h
index 9fd67b5d46..cf29e434eb 100644
--- a/include/clang/Parse/Parser.h
+++ b/include/clang/Parse/Parser.h
@@ -318,12 +318,12 @@ private:
   /// for expressions in C.
   ///
   /// This returns true if the token was annotated.
-  bool TryAnnotateTypeOrScopeToken();
+  bool TryAnnotateTypeOrScopeToken(bool EnteringContext = false);
 
   /// TryAnnotateCXXScopeToken - Like TryAnnotateTypeOrScopeToken but only
   /// annotates C++ scope specifiers.  This returns true if the token was
   /// annotated.
-  bool TryAnnotateCXXScopeToken();
+  bool TryAnnotateCXXScopeToken(bool EnteringContext = false);
 
   /// TentativeParsingAction - An object that is used as a kind of "tentative
   /// parsing transaction". It gets instantiated to mark the token position and
@@ -775,7 +775,8 @@ private:
   /// was parsed from the token stream.  Note that this routine will not parse
   /// ::new or ::delete, it will just leave them in the token stream.
   ///
-  bool ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS);
+  bool ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS, 
+                                      bool EnteringContext = false);
   
   //===--------------------------------------------------------------------===//
   // C++ 5.2p1: C++ Casts