re PR c++/10530 (Cannot access non-dependent type within nested template)

cp:
	PR c++/10530
	* pt.c (dependent_type_p_r): A dependent template-id is a class
	type with dependent template arguments, or a bound template
	template parameter.
	(type_dependent_expression_p): A template function decl cannot
	have a dependent context.
testsuite:
	PR c++/10530
	* g++.dg/template/dependent-name2.C: New test.

From-SVN: r70293

gcc/cp/ChangeLog

+2003-08-10  Nathan Sidwell  <nathan@codesourcery.com>
+
+	PR c++/10530
+	* pt.c (dependent_type_p_r): A dependent template-id is a class
+	type with dependent template arguments, or a bound template
+	template parameter.
+	(type_dependent_expression_p): A template function decl cannot
+	have a dependent context.
+
 2003-08-07  Kriang Lerdsuwanakij  <lerdsuwa@users.sourceforge.net>
 
 	PR c++/5767

gcc/cp/pt.c

@@ -11348,25 +11348,23 @@ dependent_type_p_r (tree type)
 	return true;
       return dependent_type_p (TREE_TYPE (type));
     }
+  
   /* -- a template-id in which either the template name is a template
-        parameter or any of the template arguments is a dependent type or
-	an expression that is type-dependent or value-dependent.  
-
-     This language seems somewhat confused; for example, it does not
-     discuss template template arguments.  Therefore, we use the
-     definition for dependent template arguments in [temp.dep.temp].  */
-  if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
-      && (dependent_template_id_p
-	  (CLASSTYPE_TI_TEMPLATE (type),
-	   CLASSTYPE_TI_ARGS (type))))
+     parameter ...  */
+  if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
     return true;
-  else if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
+  /* ... or any of the template arguments is a dependent type or
+	an expression that is type-dependent or value-dependent.   */
+  else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
+      && any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (type)))
     return true;
+  
   /* All TYPEOF_TYPEs are dependent; if the argument of the `typeof'
      expression is not type-dependent, then it should already been
      have resolved.  */
   if (TREE_CODE (type) == TYPEOF_TYPE)
     return true;
+  
   /* The standard does not specifically mention types that are local
      to template functions or local classes, but they should be
      considered dependent too.  For example:
@@ -11616,9 +11614,8 @@ type_dependent_expression_p (tree expression)
   if (TREE_CODE (expression) == FUNCTION_DECL
       && DECL_LANG_SPECIFIC (expression)
       && DECL_TEMPLATE_INFO (expression)
-      && (dependent_template_id_p
-	  (DECL_TI_TEMPLATE (expression),
-	   INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
+      && (any_dependent_template_arguments_p
+	  (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
     return true;
 
   if (TREE_TYPE (expression) == unknown_type_node)

gcc/testsuite/ChangeLog

+2003-08-10  Nathan Sidwell  <nathan@codesourcery.com>
+
+	PR c++/10530
+	* g++.dg/template/dependent-name2.C: New test.
+
 2003-08-08  Andrew Pinski  <pinskia@physics.uc.edu>
 
 	* g++.dg/parse/crash11.C: Put the dg options in comments.

gcc/testsuite/g++.dg/template/dependent-name2.C

+// { dg-do compile }
+
+// Copyright (C) 2003 Free Software Foundation, Inc.
+// Contributed by Nathan Sidwell 1 Aug 2003 <nathan@codesourcery.com>
+
+// PR 10530. Thought a type was dependent.
+
+template <typename T>
+struct Foo {
+  struct Inner {
+    typedef int type;
+  };
+};
+
+template <typename A> struct Bar {
+  typedef typename Foo<int>::Inner::type type;
+};
+
+template <template <typename T> class TPL> void Foo ()
+{
+  TPL<int> x;
+
+  f (x);
+}