PR c++/14409

	* pt.c (determine_specialization): For member templates, match also
	constness.

	PR c++/14448
	* parser.c (cp_parser_initializer_clause): Fold initializer if it is
	non-dependent.
	* pt.c (tsubst_copy_and_build): Handle NOP_EXPRs.

	PR c++/14409
	* g++.dg/template/spec12.C: New test.

	PR c++/14448
	* g++.dg/parse/crash14.C: New test.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@79172 138bc75d-0d04-0410-961f-82ee72b054a4

3 files changed, 38 insertions, 9 deletions

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 608a23ce763..5c40c570e8a 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,14 @@
+2004-03-09  Giovanni Bajo  <giovannibajo@gcc.gnu.org>
+
+	PR c++/14409
+	* pt.c (determine_specialization): For member templates, match also
+	constness.
+
+	PR c++/14448
+	* parser.c (cp_parser_initializer_clause): Fold initializer if it is
+	non-dependent.
+	* pt.c (tsubst_copy_and_build): Handle NOP_EXPRs.
+
 2004-03-09  Mark Mitchell  <mark@codesourcery.com>
 
 	PR c++/14230
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index b6336532037..0691c96ebc0 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -4537,9 +4537,9 @@ cp_parser_new_expression (cp_parser* parser)
          but GCC used to allowed this, so we check and emit a sensible error
 	 message for this case.  */
       if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
-	{

-	  error ("array bound forbidden after parenthesized type-id");

-	  inform ("try removing the parentheses around the type-id");

+	{
+	  error ("array bound forbidden after parenthesized type-id");
+	  inform ("try removing the parentheses around the type-id");
 	  cp_parser_direct_new_declarator (parser);
 	}
     }
@@ -11528,10 +11528,14 @@ cp_parser_initializer_clause (cp_parser* parser, bool* non_constant_p)
   /* If it is not a `{', then we are looking at an
      assignment-expression.  */
   if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
-    initializer
-      = cp_parser_constant_expression (parser,
-				       /*allow_non_constant_p=*/true,
-				       non_constant_p);
+    {
+      initializer 
+	= cp_parser_constant_expression (parser,
+					/*allow_non_constant_p=*/true,
+					non_constant_p);
+      if (!*non_constant_p)
+	initializer = fold_non_dependent_expr (initializer);
+    }
   else
     {
       /* Consume the `{' token.  */
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 7dbbdc082d7..015f72a833f 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -1249,6 +1249,7 @@ determine_specialization (tree template_id,
       if (TREE_CODE (fn) == TEMPLATE_DECL)
 	{
 	  tree decl_arg_types;
+	  tree fn_arg_types;
 
 	  /* DECL might be a specialization of FN.  */
 
@@ -1265,8 +1266,16 @@ determine_specialization (tree template_id,
 	     The specialization f<int> is invalid but is not caught
 	     by get_bindings below.  */
 
-	  if (list_length (TYPE_ARG_TYPES (TREE_TYPE (fn)))
-	      != list_length (decl_arg_types))
+	  fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
+	  if (list_length (fn_arg_types) != list_length (decl_arg_types))
+	    continue;
+
+	  /* For a non-static member function, we need to make sure that
+	     the const qualification is the same. This can be done by
+	     checking the 'this' in the argument list.  */
+	  if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
+	      && !same_type_p (TREE_VALUE (fn_arg_types), 
+			       TREE_VALUE (decl_arg_types)))
 	    continue;
 
 	  /* See whether this function might be a specialization of this
@@ -8169,6 +8178,11 @@ tsubst_copy_and_build (tree t,
     case INDIRECT_REF:
       return build_x_indirect_ref (RECUR (TREE_OPERAND (t, 0)), "unary *");
 
+    case NOP_EXPR:
+      return build_nop
+	(tsubst (TREE_TYPE (t), args, complain, in_decl),
+	 RECUR (TREE_OPERAND (t, 0)));
+
     case CAST_EXPR:
       return build_functional_cast
 	(tsubst (TREE_TYPE (t), args, complain, in_decl),