PR c++/35711 bad text in -Wcast-qual warning

["Manuel López-Ibáñez" <lopezibanez at gmail dot com>]

The message mentions constness but it means any qualifiers.
Unfortunately, with the current code is not obvious which qualifiers
are casted away, so it is better to just say "qualifiers".

Bootstrapped and regression tested on x86_64-unknown-linux-gnu with
--enable-languages=all,ada

OK for trunk?

2008-08-26  Manuel Lopez-Ibanez  <manu@gcc.gnu.org>

	PR c++/35711
cp/
	* typeck.c (check_for_casting_away_constness): We diagnose casting
	away any qualifiers not just constness.
	(casts_away_constness): Mention that it handles more than just
	constness.
testsuite/
	* g++.dg/warn/pr35711.C: New.
	* g++.dg/conversion/ptrmem2.C: Update.

Index: gcc/testsuite/g++.dg/conversion/ptrmem2.C
===================================================================
--- gcc/testsuite/g++.dg/conversion/ptrmem2.C	(revision 139749)
+++ gcc/testsuite/g++.dg/conversion/ptrmem2.C	(working copy)
@@ -29,11 +29,11 @@ int D::*p8 = static_cast<int D::*>(&A::x
 // Valid conversions which increase cv-qualification.
 const int B::*p9 = static_cast<const int B::*>(&D::x);
 const int D::*p10 = static_cast<const int D::*>(&B::x);
 
 // Invalid conversions which decrease cv-qualification.
-int B::*p11 = static_cast<int B::*>(p10); // { dg-error "casts away constness" }
-int D::*p12 = static_cast<int D::*>(p9);  // { dg-error "casts away constness" }
+int B::*p11 = static_cast<int B::*>(p10); // { dg-error "casts away qualifiers" }
+int D::*p12 = static_cast<int D::*>(p9);  // { dg-error "casts away qualifiers" }
 
 // Attempts to change member type.
 float B::*p13 = static_cast<float B::*>(&D::x); // { dg-error "" }
 float D::*p14 = static_cast<float D::*>(&B::x); // { dg-error "" }
Index: gcc/testsuite/g++.dg/warn/pr35711.C
===================================================================
--- gcc/testsuite/g++.dg/warn/pr35711.C	(revision 0)
+++ gcc/testsuite/g++.dg/warn/pr35711.C	(revision 0)
@@ -0,0 +1,8 @@
+// PR 35711
+// { dg-do compile }
+// { dg-options "-Wcast-qual" }
+
+int* foo (volatile int *p)
+{
+  return (int*)p; // { dg-warning "warning: cast from type '\[^\n\]*' to type '\[^\n\]*' casts away qualifiers" }
+}
Index: gcc/cp/typeck.c
===================================================================
--- gcc/cp/typeck.c	(revision 139749)
+++ gcc/cp/typeck.c	(working copy)
@@ -4892,42 +4892,49 @@ cp_build_compound_expr (tree lhs, tree r
 
   return build2 (COMPOUND_EXPR, TREE_TYPE (rhs), lhs, rhs);
 }
 
 /* Issue a diagnostic message if casting from SRC_TYPE to DEST_TYPE
-   casts away constness.  CAST gives the type of cast.  */
+   casts away constness.  CAST gives the type of cast.  
+
+   ??? This function warns for casting away any qualifier not just
+   const.  We would like to specify exactly what qualifiers are casted
+   away.
+*/
 
 static void
 check_for_casting_away_constness (tree src_type, tree dest_type,
 				  enum tree_code cast)
 {
   /* C-style casts are allowed to cast away constness.  With
      WARN_CAST_QUAL, we still want to issue a warning.  */
   if (cast == CAST_EXPR && !warn_cast_qual)
       return;
   
-  if (casts_away_constness (src_type, dest_type))
-    switch (cast)
-      {
-      case CAST_EXPR:
-	warning (OPT_Wcast_qual, 
-                 "cast from type %qT to type %qT casts away constness",
-		 src_type, dest_type);
-	return;
-	
-      case STATIC_CAST_EXPR:
-	error ("static_cast from type %qT to type %qT casts away constness",
-	       src_type, dest_type);
-	return;
-	
-      case REINTERPRET_CAST_EXPR:
-	error ("reinterpret_cast from type %qT to type %qT casts away constness",
+  if (!casts_away_constness (src_type, dest_type))
+    return;
+
+  switch (cast)
+    {
+    case CAST_EXPR:
+      warning (OPT_Wcast_qual, 
+	       "cast from type %qT to type %qT casts away qualifiers",
 	       src_type, dest_type);
-	return;
-      default:
-	gcc_unreachable();
-      }
+      return;
+      
+    case STATIC_CAST_EXPR:
+      error ("static_cast from type %qT to type %qT casts away qualifiers",
+	     src_type, dest_type);
+      return;
+      
+    case REINTERPRET_CAST_EXPR:
+      error ("reinterpret_cast from type %qT to type %qT casts away qualifiers",
+	     src_type, dest_type);
+      return;
+    default:
+      gcc_unreachable();
+    }
 }
 
 /* Convert EXPR (an expression with pointer-to-member type) to TYPE
    (another pointer-to-member type in the same hierarchy) and return
    the converted expression.  If ALLOW_INVERSE_P is permitted, a
@@ -7249,11 +7256,16 @@ casts_away_constness_r (tree *t1, tree *
   *t1 = cp_build_qualified_type (*t1, quals1);
   *t2 = cp_build_qualified_type (*t2, quals2);
 }
 
 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
-   constness.  */
+   constness.  
+
+   ??? This function returns non-zero if casting away qualifiers not
+   just const.  We would like to return to the caller exactly which
+   qualifiers are casted away to give more accurate diagnostics.
+*/
 
 static bool
 casts_away_constness (tree t1, tree t2)
 {
   if (TREE_CODE (t2) == REFERENCE_TYPE)