cp-tree.h (push_template_decl): Return the decl passed in, or an equivalent duplicate.

	* cp-tree.h (push_template_decl): Return the decl passed in, or an
	equivalent duplicate.
	* decl.c (pushtag): Use the return value from push_template_decl.
	(duplicate_decls): When duplicating a template declaration, merge
	the DECL_TEMPLATE_RESULTs as well.
	(make_implicit_typename): Don't try to dive into typename types to
	find a context for making a new implicit typename.
	(start_decl): Use the return value from push_template_decl.
	(grokdeclarator): Complain about declarations list `const operator
	int'.  Since we don't correctly handle in-class initializations of
	non-static data members, complain about this (now illegal)
	practice.  Issue an error for initializations of non-const statics
	since that is illegal as well, and since we don't handle that case
	correctly either.
	(start_function): Use the return value from push_template_decl.
	(start_method): Likewise.
	* decl2.c (grokfield): Likewise.  Since the change to
	grokdeclarator ensures that all initialized fields are in fact
	static, remove a redundant test for TREE_PUBLIC.
	* parse.y (initlist): Disable labeled initializers since they do
	not work as per the documentation, and since they do not use the
	same syntax as the C front end.
	* pt.c (push_template_decl): Return the decl passed in, or an
	equivalent duplicate.
	(lookup_template_class): When searching in a nested context,
	use the right arguments.
	(uses_template_parms): Handle the DECL_INITIAL for a CONST_DECL.
	* typeck.c (build_component_ref): Assign the correct type to the
	result of build_vfn_ref.

From-SVN: r17852

gcc/cp/ChangeLog

+Mon Feb  9 22:23:31 1998  Mark Mitchell  <mmitchell@usa.net>
+
+	* cp-tree.h (push_template_decl): Return the decl passed in, or an
+	equivalent duplicate.
+	* decl.c (pushtag): Use the return value from push_template_decl.
+	(duplicate_decls): When duplicating a template declaration, merge
+	the DECL_TEMPLATE_RESULTs as well.
+	(make_implicit_typename): Don't try to dive into typename types to
+	find a context for making a new implicit typename.
+	(start_decl): Use the return value from push_template_decl.
+	(grokdeclarator): Complain about declarations list `const operator
+	int'.  Since we don't correctly handle in-class initializations of
+	non-static data members, complain about this (now illegal)
+	practice.  Issue an error for initializations of non-const statics
+	since that is illegal as well, and since we don't handle that case
+	correctly either.
+	(start_function): Use the return value from push_template_decl.
+	(start_method): Likewise.
+	* decl2.c (grokfield): Likewise.  Since the change to
+	grokdeclarator ensures that all initialized fields are in fact
+	static, remove a redundant test for TREE_PUBLIC.
+	* parse.y (initlist): Disable labeled initializers since they do
+	not work as per the documentation, and since they do not use the
+	same syntax as the C front end.
+	* pt.c (push_template_decl): Return the decl passed in, or an
+	equivalent duplicate.
+	(lookup_template_class): When searching in a nested context,
+	use the right arguments.
+	(uses_template_parms): Handle the DECL_INITIAL for a CONST_DECL.
+	* typeck.c (build_component_ref): Assign the correct type to the
+	result of build_vfn_ref.
+	
 Tue Feb 10 23:56:46 1998  Jason Merrill  <jason@yorick.cygnus.com>
 
 	* pt.c (convert_nontype_argument): Fix typo.

gcc/cp/cp-tree.h

@@ -2351,7 +2351,7 @@ extern tree process_template_parm		PROTO((tree, tree));
 extern tree end_template_parm_list		PROTO((tree));
 extern void end_template_decl			PROTO((void));
 extern tree current_template_args		PROTO((void));
-extern void push_template_decl			PROTO((tree));
+extern tree push_template_decl			PROTO((tree));
 extern tree lookup_template_class		PROTO((tree, tree, tree, tree));
 extern tree lookup_template_function            PROTO((tree, tree));
 extern int uses_template_parms			PROTO((tree));

gcc/cp/decl.c

@@ -2139,7 +2139,7 @@ pushtag (name, type, globalize)
 	      TYPE_NAME (type) = d;
 	      DECL_CONTEXT (d) = context;
 	      if (! globalize && processing_template_decl && IS_AGGR_TYPE (type))
-		push_template_decl (d);
+		d = push_template_decl (d);
 
 	      if (b->parm_flag == 2)
 		d = pushdecl_class_level (d);
@@ -2155,7 +2155,7 @@ pushtag (name, type, globalize)
 	      TYPE_NAME (type) = d;
 	      DECL_CONTEXT (d) = context;
 	      if (! globalize && processing_template_decl && IS_AGGR_TYPE (type))
-		push_template_decl (d);
+		d = push_template_decl (d);
 
 	      d = pushdecl_class_level (d);
 	    }
@@ -2754,8 +2754,10 @@ duplicate_decls (newdecl, olddecl)
     {
       if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE)
 	{
-	  TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
-	  DECL_TEMPLATE_RESULT (olddecl) = DECL_TEMPLATE_RESULT (newdecl);
+	  if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
+				 DECL_TEMPLATE_RESULT (olddecl)))
+	    cp_error ("invalid redeclaration of %D", newdecl);
+	  TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
 	  DECL_TEMPLATE_PARMS (olddecl) = DECL_TEMPLATE_PARMS (newdecl);
 	}
       return 1;
@@ -4463,7 +4465,8 @@ make_implicit_typename (context, t)
 {
   tree retval;
 
-  if (uses_template_parms (DECL_CONTEXT (t))
+  if (TREE_CODE (context) != TYPENAME_TYPE 
+      && uses_template_parms (DECL_CONTEXT (t))
       && DECL_CONTEXT (t) != context)
     {
       tree binfo = get_binfo (DECL_CONTEXT (t), context, 0);
@@ -6141,7 +6144,7 @@ start_decl (declarator, declspecs, initialized)
   if (processing_template_decl)
     {
       if (! current_function_decl)
-	push_template_decl (tem);
+	tem = push_template_decl (tem);
       else if (minimal_parse_mode)
 	DECL_VINDEX (decl)
 	    = build_min_nt (DECL_STMT, copy_to_permanent (declarator),
@@ -8457,6 +8460,12 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 	type = build_complex_type (type);
     }
 
+  if (return_type == return_conversion 
+      && (RIDBIT_SETP (RID_CONST, specbits)
+	  || RIDBIT_SETP (RID_VOLATILE, specbits)))
+    cp_error ("`operator %T' cannot be cv-qualified",
+	      ctor_return_type);
+
   /* Set CONSTP if this declaration is `const', whether by
      explicit specification or via a typedef.
      Likewise for VOLATILEP.  */
@@ -9797,6 +9806,27 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 	  {
 	    if (initialized)
 	      {
+		if (!staticp)
+		  {
+		    /* An attempt is being made to initialize a non-static
+		       member.  But, from [class.mem]:
+		       
+		       4 A member-declarator can contain a
+		       constant-initializer only if it declares a static
+		       member (_class.static_) of integral or enumeration
+		       type, see _class.static.data_.  
+
+		       This used to be relatively common practice, but
+		       the rest of the compiler does not correctly
+		       handle the initialization unless the member is
+		       static so we make it static below.  */
+		    cp_pedwarn ("ANSI C++ forbids initialization of %s `%D'",
+				constp ? "const member" : "member", 
+				declarator);
+		    cp_pedwarn ("making `%D' static", declarator);
+		    staticp = 1;
+		  }
+
 		/* Motion 10 at San Diego: If a static const integral data
 		   member is initialized with an integral constant
 		   expression, the initializer may appear either in the
@@ -9804,34 +9834,21 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 		   but not both.  If it appears in the class, the member is
 		   a member constant.  The file-scope definition is always
 		   required.  */
-		if (staticp)
-		  {
-		    if (pedantic)
-		      {
-			if (! constp)
-			  cp_pedwarn ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
-				      declarator);
-
-			else if (! INTEGRAL_TYPE_P (type))
-			  cp_pedwarn ("ANSI C++ forbids member constant `%D' of non-integral type `%T'", declarator, type);
-		      }
-		  }
-
-		/* Note that initialization of const members is prohibited
-		   by the draft ANSI standard, though it appears to be in
-		   common practice.  12.6.2: The argument list is used to
-		   initialize the named nonstatic member....  This (or an
-		   initializer list) is the only way to initialize
-		   nonstatic const and reference members.  */
-		else if (pedantic || ! constp)
-		  cp_pedwarn ("ANSI C++ forbids initialization of %s `%D'",
-			      constp ? "const member" : "member", declarator);
+		if (! constp)
+		  /* According to Mike Stump, we generate bad code for
+		     this case, so we might as well always make it an
+		     error.  */
+		  cp_error ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
+			    declarator);
+		
+		if (pedantic && ! INTEGRAL_TYPE_P (type))
+		  cp_pedwarn ("ANSI C++ forbids initialization of member constant `%D' of non-integral type `%T'", declarator, type);
 	      }
 
-	    if (staticp || (constp && initialized))
+	    if (staticp)
 	      {
 		/* ANSI C++ Apr '95 wp 9.2 */
-		if (staticp && declarator == current_class_name)
+		if (declarator == current_class_name)
 		  cp_pedwarn ("ANSI C++ forbids static member `%D' with same name as enclosing class",
 			      declarator);
 
@@ -9842,7 +9859,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 		decl = build_lang_field_decl (VAR_DECL, declarator, type);
 		TREE_STATIC (decl) = 1;
 		/* In class context, 'static' means public access.  */
-		TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = !!staticp;
+		TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
 	      }
 	    else
 	      {
@@ -11616,7 +11633,7 @@ start_function (declspecs, declarator, attrs, pre_parsed_p)
      use the old decl.  */
 
   if (processing_template_decl)
-    push_template_decl (decl1);
+    decl1 = push_template_decl (decl1);
   else if (pre_parsed_p == 0)
     {
       /* A specialization is not used to guide overload resolution.  */
@@ -12667,7 +12684,7 @@ start_method (declspecs, declarator)
     DECL_INLINE (fndecl) = 1;
 
   if (processing_template_decl)
-    push_template_decl (fndecl);
+    fndecl = push_template_decl (fndecl);
 
   /* We read in the parameters on the maybepermanent_obstack,
      but we won't be getting back to them until after we

gcc/cp/decl2.c

@@ -1685,7 +1685,7 @@ grokfield (declarator, declspecs, init, asmspec_tree, attrlist)
 
   if (processing_template_decl && ! current_function_decl
       && (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == FUNCTION_DECL))
-    push_template_decl (value);
+    value = push_template_decl (value);
 
   if (attrlist)
     cplus_decl_attributes (value, TREE_PURPOSE (attrlist),
@@ -1693,38 +1693,37 @@ grokfield (declarator, declspecs, init, asmspec_tree, attrlist)
 
   if (TREE_CODE (value) == VAR_DECL)
     {
+      my_friendly_assert (TREE_PUBLIC (value), 0);
+
       /* We cannot call pushdecl here, because that would
 	 fill in the value of our TREE_CHAIN.  Instead, we
 	 modify cp_finish_decl to do the right thing, namely, to
 	 put this decl out straight away.  */
-      if (TREE_PUBLIC (value))
+      /* current_class_type can be NULL_TREE in case of error.  */
+      if (asmspec == 0 && current_class_type)
 	{
-	  /* current_class_type can be NULL_TREE in case of error.  */
-	  if (asmspec == 0 && current_class_type)
-	    {
-	      TREE_PUBLIC (value) = 1;
-	      DECL_INITIAL (value) = error_mark_node;
-	      DECL_ASSEMBLER_NAME (value)
-		= build_static_name (current_class_type, DECL_NAME (value));
-	    }
-	  if (! processing_template_decl)
-	    pending_statics = perm_tree_cons (NULL_TREE, value, pending_statics);
-
-	  /* Static consts need not be initialized in the class definition.  */
-	  if (init != NULL_TREE && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (value)))
-	    {
-	      static int explanation = 0;
-
-	      error ("initializer invalid for static member with constructor");
-	      if (explanation++ == 0)
-		error ("(you really want to initialize it separately)");
-	      init = 0;
-	    }
-	  /* Force the compiler to know when an uninitialized static
-	     const member is being used.  */
-	  if (TYPE_READONLY (value) && init == 0)
-	    TREE_USED (value) = 1;
+	  TREE_PUBLIC (value) = 1;
+	  DECL_INITIAL (value) = error_mark_node;
+	  DECL_ASSEMBLER_NAME (value)
+	    = build_static_name (current_class_type, DECL_NAME (value));
 	}
+      if (! processing_template_decl)
+	pending_statics = perm_tree_cons (NULL_TREE, value, pending_statics);
+      
+      /* Static consts need not be initialized in the class definition.  */
+      if (init != NULL_TREE && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (value)))
+	{
+	  static int explanation = 0;
+	  
+	  error ("initializer invalid for static member with constructor");
+	  if (explanation++ == 0)
+	    error ("(you really want to initialize it separately)");
+	  init = 0;
+	}
+      /* Force the compiler to know when an uninitialized static
+	 const member is being used.  */
+      if (TYPE_READONLY (value) && init == 0)
+	TREE_USED (value) = 1;
       DECL_INITIAL (value) = init;
       DECL_IN_AGGR_P (value) = 1;
       DECL_CONTEXT (value) = current_class_type;

gcc/cp/parse.y

@@ -2208,7 +2208,11 @@ initlist:
 		{ $$ = build_tree_list (NULL_TREE, $$); }
 	| initlist ',' init
 		{ $$ = expr_tree_cons (NULL_TREE, $3, $$); }
-	/* These are for labeled elements.  */
+	/* These are for labeled elements, which don't currently work
+	   as documented, or give warning messages when used with
+	   -ansi -pedantic, or match the syntax currently used in the
+	   C front-end.  They are therefore disabled.  
+
 	| '[' expr_no_commas ']' init
 		{ $$ = build_expr_list ($2, $4); }
 	| initlist ',' CASE expr_no_commas ':' init
@@ -2217,6 +2221,7 @@ initlist:
 		{ $$ = build_expr_list ($$, $3); }
 	| initlist ',' identifier ':' init
 		{ $$ = expr_tree_cons ($3, $5, $$); }
+	*/
 	;
 
 fn.defpen:

gcc/cp/pt.c

@@ -1211,7 +1211,12 @@ build_template_decl (decl, parms)
 }
 
   
-void
+/* Creates a TEMPLATE_DECL for the indicated DECL using the template
+   parameters given by current_template_args, or reuses a previously
+   existing one, if appropriate.  Returns the DECL, or an equivalent
+   one, if it is replaced via a call to duplicate_decls.  */
+
+tree
 push_template_decl (decl)
      tree decl;
 {
@@ -1246,14 +1251,14 @@ push_template_decl (decl)
 	  /* purpose: args to main template
 	     value: spec template */
 	  if (comp_template_args (TREE_PURPOSE (spec), mainargs))
-	    return;
+	    return decl;
 	}
 
       DECL_TEMPLATE_SPECIALIZATIONS (maintmpl) = CLASSTYPE_TI_SPEC_INFO (type)
 	= perm_tree_cons (mainargs, TREE_VALUE (current_template_parms),
 			  DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
       TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
-      return;
+      return decl;
     }
 
   args = current_template_args ();
@@ -1286,7 +1291,7 @@ push_template_decl (decl)
       else if (! DECL_TEMPLATE_INFO (decl))
 	{
 	  cp_error ("template definition of non-template `%#D'", decl);
-	  return;
+	  return decl;
 	}
       else
 	tmpl = DECL_TI_TEMPLATE (decl);
@@ -1315,7 +1320,7 @@ push_template_decl (decl)
 		perm_tree_cons (tmpl, args, NULL_TREE);
 
 	      register_specialization (new_tmpl, tmpl, args);
-	      return;
+	      return decl;
 	    }
 	  
 	  a = TREE_VEC_ELT (args, TREE_VEC_LENGTH (args) - 1);
@@ -1385,6 +1390,8 @@ push_template_decl (decl)
     cp_error ("template declaration of `%#D'", decl);
   else
     DECL_TEMPLATE_INFO (decl) = info;
+
+  return DECL_TEMPLATE_RESULT (tmpl);
 }
 
 
@@ -2366,8 +2373,13 @@ lookup_template_class (d1, arglist, in_decl, context)
     }
   else
     {
-      tree ctx = lookup_template_class (TYPE_CONTEXT (TREE_TYPE (template)),
-					arglist, in_decl, NULL_TREE);
+      tree type_ctx = TYPE_CONTEXT (TREE_TYPE (template));
+      tree args = tsubst (CLASSTYPE_TI_ARGS (type_ctx),
+			  arglist,
+			  TREE_VEC_LENGTH (arglist),
+			  in_decl);
+      tree ctx = lookup_template_class (type_ctx, args,
+					in_decl, NULL_TREE);
       id = d1;
       arglist = CLASSTYPE_TI_ARGS (ctx);
 
@@ -2496,6 +2508,11 @@ uses_template_parms (t)
          parameter */
       return 0;
       
+    case CONST_DECL:
+      if (uses_template_parms (DECL_INITIAL (t)))
+	return 1;
+      goto check_type_and_context;
+
     case FUNCTION_DECL:
     case VAR_DECL:
       /* ??? What about FIELD_DECLs?  */
@@ -2503,8 +2520,8 @@ uses_template_parms (t)
 	  && uses_template_parms (DECL_TI_ARGS (t)))
 	return 1;
       /* fall through */
-    case CONST_DECL:
     case PARM_DECL:
+    check_type_and_context:
       if (uses_template_parms (TREE_TYPE (t)))
 	return 1;
       if (DECL_CONTEXT (t) && uses_template_parms (DECL_CONTEXT (t)))

gcc/cp/typeck.c

@@ -1935,7 +1935,12 @@ build_component_ref (datum, component, basetype_path, protect)
 			  datum = build_indirect_ref (addr, NULL_PTR);
 			  my_friendly_assert (datum != error_mark_node, 310);
 			  fndecl = build_vfn_ref (&addr, datum, DECL_VINDEX (fndecl));
-			  TREE_TYPE (fndecl) = build_pointer_type (fntype);
+			  /* The type of fndecl is a function type,
+			     not a pointer-to-function type, since
+			     build_vfn_ref returns not the correct
+			     vtable slot, but the indirection of the
+			     correct vtable slot.  */
+			  TREE_TYPE (fndecl) = fntype;
 			}
 		      else
 			mark_used (fndecl);