When we know that we are parsing a class-name, implicitly construct a

TypenameType if getTypeName is looking at a member of an unknown
specialization. This allows us to properly parse class templates that
derived from type that could only otherwise be described by a typename type,
e.g.,

  template<class T> struct X {};
  template<typename T> struct Y : public X<T>::X { };

Fixes PR4381.

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

diff --git a/include/clang/Parse/Action.h b/include/clang/Parse/Action.h
index 70e13f7227e6a22d5d574bbd71426df51d01c6ad..5a025caaf7492f76296cd092a27b9589961e074c 100644 (file)
--- a/include/clang/Parse/Action.h
+++ b/include/clang/Parse/Action.h
@@ -170,11 +170,27 @@ public:
   
   /// getTypeName - Return non-null if the specified identifier is a type name
   /// in the current scope.
-  /// An optional CXXScopeSpec can be passed to indicate the C++ scope (class or
-  /// namespace) that the identifier must be a member of.
-  /// i.e. for "foo::bar", 'II' will be "bar" and 'SS' will be "foo::".
+  ///
+  /// \param II the identifier for which we are performing name lookup
+  ///
+  /// \param NameLoc the location of the identifier
+  ///
+  /// \param S the scope in which this name lookup occurs
+  ///
+  /// \param SS if non-NULL, the C++ scope specifier that precedes the 
+  /// identifier
+  ///
+  /// \param isClassName whether this is a C++ class-name production, in 
+  /// which we can end up referring to a member of an unknown specialization 
+  /// that we know (from the grammar) is supposed to be a type. For example,
+  /// this occurs when deriving from "std::vector<T>::allocator_type", where T 
+  /// is a template parameter.
+  ///
+  /// \returns the type referred to by this identifier, or NULL if the type
+  /// does not name an identifier.
   virtual TypeTy *getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
-                              Scope *S, const CXXScopeSpec *SS = 0) = 0;
+                              Scope *S, const CXXScopeSpec *SS = 0,
+                              bool isClassName = false) = 0;
 
   /// isTagName() - This method is called *for error recovery purposes only*
   /// to determine if the specified name is a valid tag name ("struct foo").  If
@@ -2009,8 +2025,27 @@ public:
 
   /// getTypeName - This looks at the IdentifierInfo::FETokenInfo field to
   /// determine whether the name is a typedef or not in this scope.
+  ///
+  /// \param II the identifier for which we are performing name lookup
+  ///
+  /// \param NameLoc the location of the identifier
+  ///
+  /// \param S the scope in which this name lookup occurs
+  ///
+  /// \param SS if non-NULL, the C++ scope specifier that precedes the 
+  /// identifier
+  ///
+  /// \param isClassName whether this is a C++ class-name production, in 
+  /// which we can end up referring to a member of an unknown specialization 
+  /// that we know (from the grammar) is supposed to be a type. For example,
+  /// this occurs when deriving from "std::vector<T>::allocator_type", where T 
+  /// is a template parameter.
+  ///
+  /// \returns the type referred to by this identifier, or NULL if the type
+  /// does not name an identifier.
   virtual TypeTy *getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
-                              Scope *S, const CXXScopeSpec *SS);
+                              Scope *S, const CXXScopeSpec *SS,
+                              bool isClassName = false);
 
   /// isCurrentClassName - Always returns false, because MinimalAction
   /// does not support C++ classes with constructors.

diff --git a/lib/Parse/MinimalAction.cpp b/lib/Parse/MinimalAction.cpp
index 6c8d75c2d6dbf014171f75da90d51d6ed9a2dbfc..4e32de34b7eea87412ddc45600cfdddb4a8b7d69 100644 (file)
--- a/lib/Parse/MinimalAction.cpp
+++ b/lib/Parse/MinimalAction.cpp
@@ -143,7 +143,8 @@ void MinimalAction::ActOnTranslationUnitScope(SourceLocation Loc, Scope *S) {
 /// FIXME: Use the passed CXXScopeSpec for accurate C++ type checking.
 Action::TypeTy *
 MinimalAction::getTypeName(IdentifierInfo &II, SourceLocation Loc,
-                           Scope *S, const CXXScopeSpec *SS) {
+                           Scope *S, const CXXScopeSpec *SS,
+                           bool isClassName) {
   if (TypeNameInfo *TI = II.getFETokenInfo<TypeNameInfo>())
     if (TI->isTypeName)
       return TI;

diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
index c29f601f299638bf773fc104439e0d358b6cb9c6..25bed0937b678fd42a1b07709722185c7616cbe2 100644 (file)
--- a/lib/Parse/ParseDecl.cpp
+++ b/lib/Parse/ParseDecl.cpp
@@ -2248,7 +2248,7 @@ void Parser::ParseDirectDeclarator(Declarator &D) {
       } else if (Tok.is(tok::tilde)) {
         // This should be a C++ destructor.
         SourceLocation TildeLoc = ConsumeToken();
-        if (Tok.is(tok::identifier)) {
+        if (Tok.is(tok::identifier) || Tok.is(tok::annot_template_id)) {
           // FIXME: Inaccurate.
           SourceLocation NameLoc = Tok.getLocation();
           SourceLocation EndLoc;

diff --git a/lib/Parse/ParseDeclCXX.cpp b/lib/Parse/ParseDeclCXX.cpp
index 3a82868d5ac3d1a2e12d908276db51458aa1c29e..0a97825fd92b80076f7b4e8f76f6722c208e301b 100644 (file)
--- a/lib/Parse/ParseDeclCXX.cpp
+++ b/lib/Parse/ParseDeclCXX.cpp
@@ -457,7 +457,8 @@ Parser::TypeResult Parser::ParseClassName(SourceLocation &EndLocation,
 
   // We have an identifier; check whether it is actually a type.
   TypeTy *Type = Actions.getTypeName(*Tok.getIdentifierInfo(), 
-                                     Tok.getLocation(), CurScope, SS);
+                                     Tok.getLocation(), CurScope, SS,
+                                     true);
   if (!Type) {
     Diag(Tok, DestrExpected ? diag::err_destructor_class_name 
                             : diag::err_expected_class_name);

diff --git a/lib/Sema/Sema.h b/lib/Sema/Sema.h
index f28ab80aaf0f4fd85c32d46c3a4006662d31c1cb..822589dd500b71698e56eeb2f7c78afe5996324f 100644 (file)
--- a/lib/Sema/Sema.h
+++ b/lib/Sema/Sema.h
@@ -501,7 +501,8 @@ public:
   DeclGroupPtrTy ConvertDeclToDeclGroup(DeclPtrTy Ptr);
 
   virtual TypeTy *getTypeName(IdentifierInfo &II, SourceLocation NameLoc, 
-                              Scope *S, const CXXScopeSpec *SS);
+                              Scope *S, const CXXScopeSpec *SS,
+                              bool isClassName = false);
   virtual DeclSpec::TST isTagName(IdentifierInfo &II, Scope *S);
   
   virtual DeclPtrTy ActOnDeclarator(Scope *S, Declarator &D) {

diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp
index fec9a075ecca175c09b6e115241e8bf138ab62b6..c0e4921f69e49eb728033d6ce6a0807aa44e896f 100644 (file)
--- a/lib/Sema/SemaDecl.cpp
+++ b/lib/Sema/SemaDecl.cpp
@@ -60,7 +60,8 @@ Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(DeclPtrTy Ptr) {
 /// If name lookup results in an ambiguity, this routine will complain
 /// and then return NULL.
 Sema::TypeTy *Sema::getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
-                                Scope *S, const CXXScopeSpec *SS) {
+                                Scope *S, const CXXScopeSpec *SS,
+                                bool isClassName) {
   // C++ [temp.res]p3:
   //   A qualified-id that refers to a type and in which the
   //   nested-name-specifier depends on a template-parameter (14.6.2)
@@ -70,8 +71,17 @@ Sema::TypeTy *Sema::getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
   //
   // We therefore do not perform any name lookup if the result would
   // refer to a member of an unknown specialization.
-  if (SS && isUnknownSpecialization(*SS))
-    return 0;
+  if (SS && isUnknownSpecialization(*SS)) {
+    if (!isClassName)
+      return 0;
+    
+    // We know from the grammar that this name refers to a type, so build a 
+    // TypenameType node to describe the type.
+    // FIXME: Record somewhere that this TypenameType node has no "typename"
+    // keyword associated with it.
+    return CheckTypenameType((NestedNameSpecifier *)SS->getScopeRep(),
+                             II, SS->getRange()).getAsOpaquePtr();
+  }
   
   LookupResult Result 
     = LookupParsedName(S, SS, &II, LookupOrdinaryName, false, false);

diff --git a/test/SemaTemplate/dependent-base-member-init.cpp b/test/SemaTemplate/dependent-base-member-init.cpp
index 684bce6f5a68d72f381cd36621f4201c6d4401cc..b3d707b632b1abd9127b2241ff2ff56348876358 100644 (file)
--- a/test/SemaTemplate/dependent-base-member-init.cpp
+++ b/test/SemaTemplate/dependent-base-member-init.cpp
@@ -1,5 +1,9 @@
 // RUN: clang-cc -fsyntax-only -verify %s
 
+// PR4381
+template<class T> struct X {};
+template<typename T> struct Y : public X<T>::X { };
+
 // PR4621
 class A1 {
   A1(int x) {}