[multiple changes]

Thu Sep 11 17:14:55 1997  Jason Merrill  <jason@yorick.cygnus.com>

	* decl.c (lookup_name_real): Add implicit 'typename' to types from
	base classes.

	* pt.c (most_specialized_class): Fix typo.
	(tsubst): Move constant folding to TREE_VEC case.

Thu Sep 11 10:08:45 1997  Mark Mitchell  <mmitchell@usa.net>

	* pt.c (do_poplevel): Don't warn about unused local variables
	while processing_template_decl since we don't always know whether
	or not they will need constructing/destructing.

	* pt.c (uses_template_parms): Check the values of an enumeration
	type to make sure they don't depend on template parms.

	* decl.c (make_typename_type): Don't lookup the field if the
	context uses template parms, even if we're not
	processing_template_decl at the moment.

	* pt.c (coerce_template_parms): Avoid looking at the
	TYPE_LANG_DECL portion of a typename type, since there won't be
	one.
	(tsubst): Do constant folding as necessary to make sure that
	arguments passed to lookup_template_class really are constants.

From-SVN: r15422

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index b71654274a88117dfb64614ef4977f4c74b19936..66766ed4cb97c107c96966e6f50c4a8d754c1000 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,30 @@
+Thu Sep 11 17:14:55 1997  Jason Merrill  <jason@yorick.cygnus.com>
+
+       * decl.c (lookup_name_real): Add implicit 'typename' to types from
+       base classes.
+
+       * pt.c (most_specialized_class): Fix typo.
+       (tsubst): Move constant folding to TREE_VEC case.
+
+Thu Sep 11 10:08:45 1997  Mark Mitchell  <mmitchell@usa.net>
+
+       * pt.c (do_poplevel): Don't warn about unused local variables
+       while processing_template_decl since we don't always know whether
+       or not they will need constructing/destructing.
+
+       * pt.c (uses_template_parms): Check the values of an enumeration
+       type to make sure they don't depend on template parms.
+
+       * decl.c (make_typename_type): Don't lookup the field if the
+       context uses template parms, even if we're not
+       processing_template_decl at the moment.
+
+       * pt.c (coerce_template_parms): Avoid looking at the
+       TYPE_LANG_DECL portion of a typename type, since there won't be
+       one. 
+       (tsubst): Do constant folding as necessary to make sure that
+       arguments passed to lookup_template_class really are constants. 
+
 Tue Sep  9 19:49:38 1997  Jason Merrill  <jason@yorick.cygnus.com>
 
        * pt.c (unify): Just return 0 for a TYPENAME_TYPE.

diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 3543ddd331c3f1978a9e7a776bc599416fde8383..852708033be3345c8710b54579b5a125d8363803 100644 (file)
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -4322,8 +4322,7 @@ make_typename_type (context, name)
   else if (TREE_CODE (name) != IDENTIFIER_NODE)
     my_friendly_abort (2000);
 
-  if (! processing_template_decl
-      || ! uses_template_parms (context)
+  if (! uses_template_parms (context)
       || context == current_class_type)
     {
       t = lookup_field (context, name, 0, 1);
@@ -4432,7 +4431,7 @@ lookup_name_real (name, prefer_type, nonclass)
       else
        val = NULL_TREE;
 
-#if 1
+      /* Add implicit 'typename' to scoped types from other classes.  */
       if (got_scope && processing_template_decl
          && got_scope != current_class_type
          && uses_template_parms (got_scope)
@@ -4443,7 +4442,6 @@ lookup_name_real (name, prefer_type, nonclass)
          TREE_TYPE (t) = TREE_TYPE (val);
          val = TYPE_MAIN_DECL (t);
        }
-#endif
 
       if (got_scope)
        goto done;
@@ -4473,6 +4471,19 @@ lookup_name_real (name, prefer_type, nonclass)
         created the COMPONENT_REF or anything like that.  */
       if (classval == NULL_TREE)
        classval = lookup_nested_field (name, ! yylex);
+
+      /* Add implicit 'typename' to types from base classes.  */
+      if (processing_template_decl
+         && classval && TREE_CODE (classval) == TYPE_DECL
+         && DECL_CONTEXT (classval) != current_class_type
+         && uses_template_parms (DECL_CONTEXT (classval))
+         && ! DECL_ARTIFICIAL (classval))
+       {
+         tree t = make_typename_type (DECL_CONTEXT (classval),
+                                      DECL_NAME (classval));
+         TREE_TYPE (t) = TREE_TYPE (classval);
+         classval = TYPE_MAIN_DECL (t);
+       }
     }
 
   if (locval && classval)

diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 83e50407f0b84076b75006bf646c0390f4315a72..8df5038b9ab5d20a0bc510d1cfc90d78de806ea3 100644 (file)
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -658,7 +658,8 @@ coerce_template_parms (parms, arglist, in_decl)
          if (! processing_template_decl)
            {
              tree t = target_type (val);
-             if (IS_AGGR_TYPE (t)
+             if (TREE_CODE (t) != TYPENAME_TYPE 
+                 && IS_AGGR_TYPE (t)
                  && decl_function_context (TYPE_MAIN_DECL (t)))
                {
                  cp_error ("type `%T' composed from a local class is not a valid template-argument", val);
@@ -1146,10 +1147,19 @@ uses_template_parms (t)
     case REAL_TYPE:
     case COMPLEX_TYPE:
     case VOID_TYPE:
-    case ENUMERAL_TYPE:
     case BOOLEAN_TYPE:
       return 0;
 
+    case ENUMERAL_TYPE:
+      {
+       tree v;
+
+       for (v = TYPE_VALUES (t); v != NULL_TREE; v = TREE_CHAIN (v))
+         if (uses_template_parms (TREE_VALUE (v)))
+           return 1;
+      }
+      return 0;
+
       /* constants */
     case INTEGER_CST:
     case REAL_CST:
@@ -2084,6 +2094,8 @@ tsubst (t, args, nargs, in_decl)
     case TREE_VEC:
       if (type != NULL_TREE)
        {
+         /* A binfo node.  */
+
          t = copy_node (t);
 
          if (type == TREE_TYPE (t))
@@ -2099,6 +2111,8 @@ tsubst (t, args, nargs, in_decl)
            }
          return t;
        }
+
+      /* Otherwise, a vector of template arguments.  */
       {
        int len = TREE_VEC_LENGTH (t), need_new = 0, i;
        tree *elts = (tree *) alloca (len * sizeof (tree));
@@ -2108,6 +2122,24 @@ tsubst (t, args, nargs, in_decl)
        for (i = 0; i < len; i++)
          {
            elts[i] = tsubst_expr (TREE_VEC_ELT (t, i), args, nargs, in_decl);
+
+           if (TREE_CODE_CLASS (TREE_CODE (elts[i])) != 't'
+               && !uses_template_parms (elts[i]))
+             {
+               /* Sometimes, one of the args was an expression involving a
+                  template constant parameter, like N - 1.  Now that we've
+                  tsubst'd, we might have something like 2 - 1.  This will
+                  confuse lookup_template_class, so we do constant folding
+                  here.  We have to unset processing_template_decl, to
+                  fool build_expr_from_tree() into building an actual
+                  tree.  */
+
+               int saved_processing_template_decl = processing_template_decl; 
+               processing_template_decl = 0;
+               elts[i] = fold (build_expr_from_tree (elts[i]));
+               processing_template_decl = saved_processing_template_decl; 
+             }
+
            if (elts[i] != TREE_VEC_ELT (t, i))
              need_new = 1;
          }
@@ -2305,8 +2337,16 @@ tree
 do_poplevel ()
 {
   tree t;
+  int saved_warn_unused;
 
+  if (processing_template_decl)
+    {
+      saved_warn_unused = warn_unused;
+      warn_unused = 0;
+    }
   expand_end_bindings (getdecls (), kept_level_p (), 1);
+  if (processing_template_decl)
+    warn_unused = saved_warn_unused;
   t = poplevel (kept_level_p (), 1, 0);
   pop_momentary ();
   return t;
@@ -3566,7 +3606,7 @@ most_specialized_class (specs, mainargs)
 
   for (t = list; t && t != champ; t = TREE_CHAIN (t))
     {
-      fate = more_specialized (champ, t);
+      fate = more_specialized_class (champ, t);
       if (fate != 1)
        return error_mark_node;
     }