C++ PATCH: PR 25369

[Mark Mitchell <mark at codesourcery dot com>]

This patch fixes a case where we were failing to emit a definition of
an inline template function.  The problem is that the function never
ended up on the instantiated template list, because we never called
mark_used during instantiation.  The change in tsubst_copy takes care
of that.  I did a little related cleanup, and removed
tsubst_call_declarator_parms, which I noticed was no longer used.

Tested on x86_64-unknown-linux-gnu, applied on the 4.0 branch, 4.1
branch, and mainline.  (On the branches, I applied just the
tsubst_copy and mark_used changes, for safety.)

--
Mark Mitchell
CodeSourcery, LLC
mark@codesourcery.com

2005-12-22  Mark Mitchell  <mark@codesourcery.com>

	PR c++/25369
	* tree.c (really_overloaded_fn): Tweak comment.
	* pt.c (tsubst_call_declarator_parms): Remove.
	(tsubst_copy): Call mark_used on the member referenced by an
	OFFSET_REF.
	* semantics.c (finish_qualified_id_expr): Simplify.
	* decl2.c (mark_used): Accept BASELINKs.

2005-12-22  Mark Mitchell  <mark@codesourcery.com>

	PR c++/25369
	* g++.dg/template/ptrmem16.C: New test.

Index: gcc/cp/tree.c
===================================================================
--- gcc/cp/tree.c	(revision 108972)
+++ gcc/cp/tree.c	(working copy)
@@ -843,9 +843,9 @@ is_overloaded_fn (tree x)
 int
 really_overloaded_fn (tree x)
 {
-  /* A baselink is also considered an overloaded function.  */
   if (TREE_CODE (x) == OFFSET_REF)
     x = TREE_OPERAND (x, 1);
+  /* A baselink is also considered an overloaded function.  */
   if (BASELINK_P (x))
     x = BASELINK_FUNCTIONS (x);
 
Index: gcc/cp/pt.c
===================================================================
--- gcc/cp/pt.c	(revision 108972)
+++ gcc/cp/pt.c	(working copy)
@@ -144,7 +144,6 @@ static void check_specialization_scope (
 static tree process_partial_specialization (tree);
 static void set_current_access_from_decl (tree);
 static void check_default_tmpl_args (tree, tree, int, int);
-static tree tsubst_call_declarator_parms (tree, tree, tsubst_flags_t, tree);
 static tree get_template_base (tree, tree, tree, tree);
 static int verify_class_unification (tree, tree, tree);
 static tree try_class_unification (tree, tree, tree, tree);
@@ -6946,39 +6945,6 @@ tsubst_exception_specification (tree fnt
   return new_specs;
 }
 
-/* Substitute into the PARMS of a call-declarator.  */
-
-static tree
-tsubst_call_declarator_parms (tree parms,
-			      tree args,
-			      tsubst_flags_t complain,
-			      tree in_decl)
-{
-  tree new_parms;
-  tree type;
-  tree defarg;
-
-  if (!parms || parms == void_list_node)
-    return parms;
-
-  new_parms = tsubst_call_declarator_parms (TREE_CHAIN (parms),
-					    args, complain, in_decl);
-
-  /* Figure out the type of this parameter.  */
-  type = tsubst (TREE_VALUE (parms), args, complain, in_decl);
-
-  /* Figure out the default argument as well.  Note that we use
-     tsubst_expr since the default argument is really an expression.  */
-  defarg = tsubst_expr (TREE_PURPOSE (parms), args, complain, in_decl);
-
-  /* Chain this parameter on to the front of those we have already
-     processed.  We don't use hash_tree_cons because that function
-     doesn't check TREE_PARMLIST.  */
-  new_parms = tree_cons (defarg, type, new_parms);
-
-  return new_parms;
-}
-
 /* Take the tree structure T and replace template parameters used
    therein with the argument vector ARGS.  IN_DECL is an associated
    decl for diagnostics.  If an error occurs, returns ERROR_MARK_NODE.
@@ -8111,6 +8077,10 @@ tsubst_copy (tree t, tree args, tsubst_f
 	 in response to the saved STMT_IS_FULL_EXPR_P setting.  */
       gcc_unreachable ();
 
+    case OFFSET_REF:
+      mark_used (TREE_OPERAND (t, 1));
+      return t;
+
     default:
       return t;
     }
Index: gcc/cp/semantics.c
===================================================================
--- gcc/cp/semantics.c	(revision 108973)
+++ gcc/cp/semantics.c	(working copy)
@@ -1513,12 +1513,8 @@ finish_qualified_id_expr (tree qualifyin
   if (error_operand_p (expr))
     return error_mark_node;
 
-  if (DECL_P (expr))
+  if (DECL_P (expr) || BASELINK_P (expr))
     mark_used (expr);
-  else if (BASELINK_P (expr)
-	   && TREE_CODE (BASELINK_FUNCTIONS (expr)) != TEMPLATE_ID_EXPR
-	   && !really_overloaded_fn (BASELINK_FUNCTIONS (expr)))
-    mark_used (OVL_CURRENT (BASELINK_FUNCTIONS (expr)));
 
   if (template_p)
     check_template_keyword (expr);
Index: gcc/cp/decl2.c
===================================================================
--- gcc/cp/decl2.c	(revision 108972)
+++ gcc/cp/decl2.c	(working copy)
@@ -3233,14 +3233,27 @@ check_default_args (tree x)
     }
 }
 
-/* Mark DECL as "used" in the program.  If DECL is a specialization or
-   implicitly declared class member, generate the actual definition.  */
+/* Mark DECL (eithet a _DECL or a BASELINK) as "used" in the program.
+   If DECL is a specialization or implicitly declared class member,
+   generate the actual definition.  */
 
 void
 mark_used (tree decl)
 {
   HOST_WIDE_INT saved_processing_template_decl = 0;
 
+  /* If DECL is a BASELINK for a single function, then treat it just
+     like the DECL for the function.  Otherwise, if the BASELINK is
+     for an overloaded function, we don't know which function was
+     actually used until after overload resolution.  */
+  if (TREE_CODE (decl) == BASELINK)
+    {
+      decl = BASELINK_FUNCTIONS (decl);
+      if (really_overloaded_fn (decl))
+	return;
+      decl = OVL_CURRENT (decl);
+    }
+
   TREE_USED (decl) = 1;
   /* If we don't need a value, then we don't need to synthesize DECL.  */ 
   if (skip_evaluation)
Index: gcc/testsuite/g++.dg/template/ptrmem16.C
===================================================================
--- gcc/testsuite/g++.dg/template/ptrmem16.C	(revision 0)
+++ gcc/testsuite/g++.dg/template/ptrmem16.C	(revision 0)
@@ -0,0 +1,22 @@
+// PR c++/25369
+// { dg-do link }
+
+template <typename> struct A 
+{
+  void foo() {}
+};
+
+void bar(void (A<int>::*)()) {}
+
+template <int> void baz()
+{
+  bar(&A<int>::foo);
+}
+
+int main()
+{
+  baz<0>();
+  return 0;
+}
+
+