cp-tree.h (IS_AGGR_TYPE): Include instantiated template template parameters.

	* cp-tree.h (IS_AGGR_TYPE): Include instantiated template template
	parameters.
	(IMPLICIT_TYPENAME_TYPE_DECL_P): New macro.
	* decl.c (push_class_binding): Use it.
	(lookup_name_real): Likewise.

From-SVN: r27948

6 files changed, 27 insertions, 14 deletions

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 40d5aac..90011a3 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,11 @@
+1999-07-05  Mark Mitchell  <mark@codesourcery.com>
+
+	* cp-tree.h (IS_AGGR_TYPE): Include instantiated template template
+	parameters.
+	(IMPLICIT_TYPENAME_TYPE_DECL_P): New macro.
+	* decl.c (push_class_binding): Use it.
+	(lookup_name_real): Likewise.
+
 1999-07-02  Gavin Romig-Koch  <gavin@cygnus.com>
 
 	* cp-tree.h (widest_integer_literal_type_node,
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 28c7e3f..b84a6ad 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -587,13 +587,16 @@ enum languages { lang_c, lang_cplusplus, lang_java };
 #define TYPE_MAIN_DECL(NODE) (TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE)))
 
 /* Nonzero if T is a class (or struct or union) type.  Also nonzero
-   for template type parameters and typename types.  Despite its name,
+   for template type parameters, typename types, and instantiated
+   template template parameters.  Despite its name,
    this macro has nothing to do with the definition of aggregate given
    in the standard.  Think of this macro as MAYBE_CLASS_TYPE_P.  */
 #define IS_AGGR_TYPE(t)				\
-  (TREE_CODE (t) == TEMPLATE_TYPE_PARM 		\
-   || TREE_CODE (t) == TYPENAME_TYPE 		\
+  (TREE_CODE (t) == TEMPLATE_TYPE_PARM		\
+   || TREE_CODE (t) == TYPENAME_TYPE		\
    || TREE_CODE (t) == TYPEOF_TYPE		\
+   || (TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM	\
+       && TYPE_TEMPLATE_INFO (t))		\
    || TYPE_LANG_FLAG_5 (t))
 
 /* Set IS_AGGR_TYPE for T to VAL.  T must be a class, struct, or 
@@ -1517,6 +1520,13 @@ struct lang_decl
 #define IMPLICIT_TYPENAME_P(NODE) \
   (TREE_CODE (NODE) == TYPENAME_TYPE && TREE_TYPE (NODE))
 
+/* Nonzero if NODE is a TYPE_DECL that should not be visible because
+   it is from a dependent base class.  */
+#define IMPLICIT_TYPENAME_TYPE_DECL_P(NODE) 	\
+  (TREE_CODE (NODE) == TYPE_DECL		\
+   && DECL_ARTIFICIAL (NODE)			\
+   && IMPLICIT_TYPENAME_P (TREE_TYPE (NODE)))
+
 /* Nonzero in INTEGER_CST means that this int is negative by dint of
    using a twos-complement negated operand.  */
 #define TREE_NEGATED_INT(NODE) (TREE_LANG_FLAG_0 (NODE))
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 1b6b268..cad878a 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -1256,8 +1256,7 @@ push_class_binding (id, decl)
 	 context for an implicit typename declaration is always
 	 the derived class in which the lookup was done, so the checks
 	 based on the context of DECL below will not trigger.  */
-      if (TREE_CODE (decl) == TYPE_DECL 
-	  && IMPLICIT_TYPENAME_P (TREE_TYPE (decl)))
+      if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
 	INHERITED_VALUE_BINDING_P (binding) = 1;
       else
 	{
@@ -5877,15 +5876,13 @@ lookup_name_real (name, prefer_type, nonclass, namespaces_only)
 	binding = NULL_TREE;
 
       if (binding
-	  && (!val || !(TREE_CODE (binding) == TYPE_DECL
-			&& IMPLICIT_TYPENAME_P (TREE_TYPE (binding)))))
+	  && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
 	{
 	  if (val_is_implicit_typename && !yylex)
 	    warn_about_implicit_typename_lookup (val, binding);
 	  val = binding;
 	  val_is_implicit_typename 
-	    = (TREE_CODE (val) == TYPE_DECL
-	       && IMPLICIT_TYPENAME_P (TREE_TYPE (val)));
+	    = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
 	  if (!val_is_implicit_typename)
 	    break;
 	}
diff --git a/gcc/testsuite/g++.old-deja/g++.oliva/template2.C b/gcc/testsuite/g++.old-deja/g++.oliva/template2.C
index 2f938e8..15874f0 100644
--- a/gcc/testsuite/g++.old-deja/g++.oliva/template2.C
+++ b/gcc/testsuite/g++.old-deja/g++.oliva/template2.C
@@ -11,4 +11,4 @@ template <template <typename> class C, typename T> class foo {
 };
 
 template <template <typename> class C, typename T> foo<C,T>::foo(bar)
-{} // gets bogus error - C<T> not a class - XFAIL *-*-*
+{} // gets bogus error - C<T> not a class
diff --git a/gcc/testsuite/g++.old-deja/g++.oliva/typename1.C b/gcc/testsuite/g++.old-deja/g++.oliva/typename1.C
index af3d658..d46ec60 100644
--- a/gcc/testsuite/g++.old-deja/g++.oliva/typename1.C
+++ b/gcc/testsuite/g++.old-deja/g++.oliva/typename1.C
@@ -5,8 +5,6 @@
 // by Alexandre Oliva <oliva@dcc.unicamp.br>
 // based on bug report by Nick Rasmussen <nick@jive.org>
 
-// crash test - XFAIL *-*-*
-
 template <class T> struct foo;
 
 template <class T> struct bar {
@@ -14,6 +12,6 @@ template <class T> struct bar {
 };
 
 template <class T> struct baz {
-  typedef bar<T>::foo foo; // ERROR - missing typename
+  typedef bar<T>::foo foo; // ERROR - missing typename - XFAIL *-*-*
   void m(foo);
 };
diff --git a/gcc/testsuite/g++.old-deja/g++.oliva/typename2.C b/gcc/testsuite/g++.old-deja/g++.oliva/typename2.C
index f50ef48..2428206 100644
--- a/gcc/testsuite/g++.old-deja/g++.oliva/typename2.C
+++ b/gcc/testsuite/g++.old-deja/g++.oliva/typename2.C
@@ -24,5 +24,5 @@ template <class T> struct bar {
 
 template <class T> struct baz {
   typedef bar<T>::foo foo; // ERROR - implicit typename - XFAIL *-*-*
-  void m(foo); // gets bogus error - dependent base class - XFAIL *-*-*
+  void m(foo); 
 };