public inbox for gcc-patches@gcc.gnu.org
 help / color / mirror / Atom feed
* [PATCH, c++] Emit the diagnostic messages of convert_to_void
@ 2010-06-17  8:49 Shujing Zhao
  2010-06-17  9:38 ` Shujing Zhao
  0 siblings, 1 reply; 8+ messages in thread
From: Shujing Zhao @ 2010-06-17  8:49 UTC (permalink / raw)
  To: GCC Patches; +Cc: Gabriel Dos Reis, Paolo Carlini

[-- Attachment #1: Type: text/plain, Size: 189 bytes --]

Hi,

This patch is to fix the diagnostic issues of function convert_to_void, just 
like the previous one.
Tested on i686-pc-linux-gnu with no regression.
Is it ok for trunk?

Thanks
Pearly

[-- Attachment #2: ChangeLog --]
[-- Type: text/plain, Size: 241 bytes --]

2010-06-17  Shujing Zhao  <pearly.zhao@oracle.com>

	* cp-tree.h (impl_conv_void): New type.
	(convert_to_void): Adjust prototype.
	* cvt.h (convert_to_void): Use impl_conv_void and emit the diagnostic
	for easy translation. Change caller.


[-- Attachment #3: diagnostic.patch --]
[-- Type: text/x-patch, Size: 13734 bytes --]

Index: cvt.c
===================================================================
--- cvt.c	(revision 160644)
+++ cvt.c	(working copy)
@@ -814,19 +814,18 @@ ocp_convert (tree type, tree expr, int c
    make it impossible to ignore the reference return value from functions. We
    issue warnings in the confusing cases.
 
-   IMPLICIT is non-NULL iff an expression is being implicitly converted; it
-   is NULL when the user is explicitly converting an expression to void via
-   a cast.  When non-NULL, IMPLICIT is a string indicating the context of
-   the implicit conversion.  */
+   The IMPLICIT is ICV_NULL when the user is explicitly converting an expression
+   to void via a cast. If an expression is being implicitly converted, IMPLICIT
+   indicates the context of the implicit conversion.  */
 
 tree
-convert_to_void (tree expr, const char *implicit, tsubst_flags_t complain)
+convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain)
 {
   if (expr == error_mark_node
       || TREE_TYPE (expr) == error_mark_node)
     return error_mark_node;
 
-  if (implicit == NULL)
+  if (implicit == ICV_NULL)
     mark_exp_read (expr);
   else
     {
@@ -865,12 +864,17 @@ convert_to_void (tree expr, const char *
 	tree op1 = TREE_OPERAND (expr,1);
 	tree op2 = TREE_OPERAND (expr,2);
 	bool side_effects = TREE_SIDE_EFFECTS (op1) || TREE_SIDE_EFFECTS (op2);
-	tree new_op1 = convert_to_void
-	  (op1, (implicit && !side_effects
-		 ? "second operand of conditional" : NULL), complain);
-	tree new_op2 = convert_to_void
-	  (op2, (implicit && !side_effects
-		 ? "third operand of conditional" : NULL), complain);
+	tree new_op1, new_op2;
+	if (implicit != ICV_NULL && !side_effects)
+	  {
+	    new_op1 = convert_to_void (op1, ICV_SECOND_OF_COND, complain);
+	    new_op2 = convert_to_void (op2, ICV_THIRD_OF_COND, complain);
+	  }
+	else
+	  {
+	    new_op1 = convert_to_void (op1, ICV_NULL, complain);
+	    new_op2 = convert_to_void (op2, ICV_NULL, complain);
+	  }
 
 	expr = build3 (COND_EXPR, TREE_TYPE (new_op1),
 		       TREE_OPERAND (expr, 0), new_op1, new_op2);
@@ -881,9 +885,11 @@ convert_to_void (tree expr, const char *
       {
 	/* The second part of a compound expr contains the value.  */
 	tree op1 = TREE_OPERAND (expr,1);
-	tree new_op1 = convert_to_void
-	  (op1, (implicit && !TREE_NO_WARNING (expr)
-		 ? "right-hand operand of comma" : NULL), complain);
+	tree new_op1;
+	if (implicit != ICV_NULL && !TREE_NO_WARNING (expr))
+	  new_op1 = convert_to_void (op1, ICV_RIGHT_OF_COMMA, complain);
+	else
+	  new_op1 = convert_to_void (op1, ICV_NULL, complain);
 
 	if (new_op1 != op1)
 	  {
@@ -915,17 +921,88 @@ convert_to_void (tree expr, const char *
 	if (is_volatile && !is_complete)
           {
             if (complain & tf_warning)
-              warning (0, "object of incomplete type %qT will not be accessed in %s",
-                       type, implicit ? implicit : "void context");
+	      switch (implicit)
+		{
+	      	  case ICV_NULL:
+		    warning (0, "object of incomplete type %qT will not "
+			    	"be accessed in void context", type);
+		    break;
+		  case ICV_SECOND_OF_COND:
+		    warning (0, "object of incomplete type %qT will not "
+		    		"be accessed in second operand of conditional",
+			     type);
+		    break;
+		  case ICV_THIRD_OF_COND:
+		    warning (0, "object of incomplete type %qT will not "
+		  	      	"be accessed in third operand of conditional",
+			     type);
+		    break;
+		  case ICV_RIGHT_OF_COMMA:
+		    warning (0, "object of incomplete type %qT will not "
+		    		"be accessed in right-hand operand of comma",
+			     type);
+		    break;
+		  case ICV_LEFT_OF_COMMA:
+		    warning (0, "object of incomplete type %qT will not "
+		    		"be accessed in left-hand operand of comma",
+			     type);
+		    break;
+		  case ICV_STATEMENT:
+		     warning (0, "object of incomplete type %qT will not "
+		     		 "be accessed in statement",  type);
+		     break;
+		  case ICV_THIRD_IN_FOR:
+		    warning (0, "object of incomplete type %qT will not "
+		    		"be accessed in 3rd expression in for ",
+			     type);
+		    break;
+		  default:
+		    gcc_unreachable ();
+		}
           }
 	/* Don't load the value if this is an implicit dereference, or if
 	   the type needs to be handled by ctors/dtors.  */
 	else if (is_volatile && (is_reference || TREE_ADDRESSABLE (type)))
           {
             if (complain & tf_warning)
-              warning (0, "object of type %qT will not be accessed in %s",
-                       TREE_TYPE (TREE_OPERAND (expr, 0)),
-                       implicit ? implicit : "void context");
+	      switch (implicit)
+		{
+	      	  case ICV_NULL:
+		    warning (0, "object of type %qT will not "
+			    	"be accessed in void context", type);
+		    break;
+		  case ICV_SECOND_OF_COND:
+		    warning (0, "object of type %qT will not "
+		    		"be accessed in second operand of conditional",
+			     type);
+		    break;
+		  case ICV_THIRD_OF_COND:
+		    warning (0, "object of type %qT will not "
+		  	      	"be accessed in third operand of conditional",
+			     type);
+		    break;
+		  case ICV_RIGHT_OF_COMMA:
+		    warning (0, "object of type %qT will not "
+		    		"be accessed in right-hand operand of comma",
+			     type);
+		    break;
+		  case ICV_LEFT_OF_COMMA:
+		    warning (0, "object of type %qT will not "
+		    		"be accessed in left-hand operand of comma",
+			     type);
+		    break;
+		  case ICV_STATEMENT:
+		     warning (0, "object of type %qT will not "
+		     		 "be accessed in statement",  type);
+		     break;
+		  case ICV_THIRD_IN_FOR:
+		    warning (0, "object of type %qT will not "
+		    		"be accessed in 3rd expression in for ",
+			     type);
+		    break;
+		  default:
+		    gcc_unreachable ();
+		}
           }
 	if (is_reference || !is_volatile || !is_complete || TREE_ADDRESSABLE (type))
           {
@@ -936,7 +1013,7 @@ convert_to_void (tree expr, const char *
                - automatic dereferencing of references, since the user cannot
                  control it. (See also warn_if_unused_value() in stmt.c.)  */
             if (warn_unused_value
-		&& implicit
+		&& implicit != ICV_NULL
                 && (complain & tf_warning)
                 && !TREE_NO_WARNING (expr)
                 && !is_reference)
@@ -954,8 +1031,45 @@ convert_to_void (tree expr, const char *
 	int is_complete = COMPLETE_TYPE_P (complete_type (type));
 
 	if (TYPE_VOLATILE (type) && !is_complete && (complain & tf_warning))
-	  warning (0, "object %qE of incomplete type %qT will not be accessed in %s",
-		   expr, type, implicit ? implicit : "void context");
+	  switch (implicit)
+	    {
+	      case ICV_NULL:
+		warning (0, "object %qE of incomplete type %qT will not "
+			    "be accessed in void context", expr, type);
+		break;
+	      case ICV_SECOND_OF_COND:
+	        warning (0, "object %qE of incomplete type %qT will not "
+			    "be accessed in second operand of conditional",
+			 expr, type);
+		break;
+	      case ICV_THIRD_OF_COND:
+	        warning (0, "object %qE of incomplete type %qT will not "
+			    "be accessed in third operand of conditional",
+			 expr, type);
+		break;
+	      case ICV_RIGHT_OF_COMMA:
+	        warning (0, "object %qE of incomplete type %qT will not "
+			    "be accessed in right-hand operand of comma",
+			 expr, type);
+		break;
+	      case ICV_LEFT_OF_COMMA:
+	        warning (0, "object %qE of incomplete type %qT will not "
+			    "be accessed in left-hand operand of comma",
+			 expr, type);
+		break;
+	      case ICV_STATEMENT:
+	        warning (0, "object %qE of incomplete type %qT will not "
+		            "be accessed in statement", expr, type);
+		break;
+	      case ICV_THIRD_IN_FOR:
+	        warning (0, "object %qE of incomplete type %qT will not "
+			    "be accessed in 3rd expression in for ",
+		         expr, type);
+		break;
+	      default:
+	        gcc_unreachable ();
+	    }
+
 	break;
       }
 
@@ -994,18 +1108,81 @@ convert_to_void (tree expr, const char *
 	/* [over.over] enumerates the places where we can take the address
 	   of an overloaded function, and this is not one of them.  */
 	if (complain & tf_error)
-	  error ("%s cannot resolve address of overloaded function",
-		 implicit ? implicit : "void cast");
+	  switch (implicit)
+	    {
+	      case ICV_NULL:
+		error ("void cast "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_SECOND_OF_COND:
+		error ("second operand of conditional "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_THIRD_OF_COND:
+		error ("third operand of conditional "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_RIGHT_OF_COMMA:
+		error ("right-hand operand of comma "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_LEFT_OF_COMMA:
+		error ("left-hand operand of comma "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_STATEMENT:
+		error ("statement "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_THIRD_IN_FOR:
+		error ("3rd expression in for "
+		       "cannot resolve address of overloaded function");
+		break;
+	    }
 	else
 	  return error_mark_node;
 	expr = void_zero_node;
       }
-    else if (implicit && probe == expr && is_overloaded_fn (probe))
+    else if (implicit != IRC_NULL && probe == expr && is_overloaded_fn (probe))
       {
 	/* Only warn when there is no &.  */
 	if (complain & tf_warning)
-	  warning (OPT_Waddress, "%s is a reference, not call, to function %qE",
-		   implicit, expr);
+	  switch (implicit)
+	    {
+	      case ICV_SECOND_OF_COND:
+	        warning (OPT_Waddress,
+			 "second operand of conditional "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      case ICV_THIRD_OF_COND:
+	        warning (OPT_Waddress,
+			 "third operand of conditional "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      case ICV_RIGHT_OF_COMMA:
+	        warning (OPT_Waddress,
+			 "right-hand operand of comma "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      case ICV_LEFT_OF_COMMA:
+	        warning (OPT_Waddress,
+			 "left-hand operand of comma "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      case ICV_STATEMENT:
+	        warning (OPT_Waddress,
+			 "statement "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      case ICV_THIRD_IN_FOR:
+	        warning (OPT_Waddress,
+			 "3rd expression in for "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      default:
+	        gcc_unreachable ();
+	    }
+
 	if (TREE_CODE (expr) == COMPONENT_REF)
 	  expr = TREE_OPERAND (expr, 0);
       }
@@ -1013,7 +1190,7 @@ convert_to_void (tree expr, const char *
 
   if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr)))
     {
-      if (implicit
+      if (implicit != ICV_NULL
 	  && warn_unused_value
 	  && !TREE_NO_WARNING (expr)
 	  && !processing_template_decl)
@@ -1022,7 +1199,35 @@ convert_to_void (tree expr, const char *
 	     been explicitly cast to void, so we must do so here.  */
 	  if (!TREE_SIDE_EFFECTS (expr)) {
             if (complain & tf_warning)
-              warning (OPT_Wunused_value, "%s has no effect", implicit);
+	      switch (implicit)
+		{
+		  case ICV_SECOND_OF_COND:
+		    warning (OPT_Wunused_value,
+			     "second operand of conditional has no effect");
+		    break;
+		  case ICV_THIRD_OF_COND:
+		    warning (OPT_Wunused_value,
+		    	     "third operand of conditional has no effect");
+		    break;
+		  case ICV_RIGHT_OF_COMMA:
+		    warning (OPT_Wunused_value,
+		    	     "right-hand operand of comma has no effect");
+		    break;
+		  case ICV_LEFT_OF_COMMA:
+		    warning (OPT_Wunused_value,
+		    	     "left-hand operand of comma has no effect");
+		    break;
+		  case ICV_STATEMENT:
+		    warning (OPT_Wunused_value,
+		    	     "statement has no effect");
+		    break;
+		  case ICV_THIRD_IN_FOR:
+		    warning (OPT_Wunused_value,
+		    	     "3rd expression in for has no effect");
+		    break;
+		  default:
+		    gcc_unreachable ();
+		}
           }
 	  else
 	    {
Index: cp-tree.h
===================================================================
--- cp-tree.h	(revision 160644)
+++ cp-tree.h	(working copy)
@@ -435,6 +435,17 @@ typedef enum impl_conv_rhs {
   ICR_ASSIGN            /* assignment */
 } impl_conv_rhs;
 
+/* Possible cases of implicit or explicit bad conversions to void. */
+typedef enum impl_conv_void {
+  ICV_NULL,		/* NULL */
+  ICV_SECOND_OF_COND,	/* second operand of conditional */
+  ICV_THIRD_OF_COND,	/* third operand of conditional */
+  ICV_RIGHT_OF_COMMA,	/* right-hand operand of comma */
+  ICV_LEFT_OF_COMMA,	/* left-hand operand of comma */
+  ICV_STATEMENT,	/* statement */
+  ICV_THIRD_IN_FOR	/* 3rd expression in for */
+} impl_conv_void;
+
 /* Macros for access to language-specific slots in an identifier.  */
 
 #define IDENTIFIER_NAMESPACE_BINDINGS(NODE)	\
@@ -4669,8 +4680,8 @@ extern tree ocp_convert				(tree, tree, 
 extern tree cp_convert				(tree, tree);
 extern tree cp_convert_and_check                (tree, tree);
 extern tree cp_fold_convert			(tree, tree);
-extern tree convert_to_void	(tree, const char */*implicit context*/,
-                                 tsubst_flags_t);
+extern tree convert_to_void			(tree, impl_conv_void,
+						 tsubst_flags_t);
 extern tree convert_force			(tree, tree, int);
 extern tree build_expr_type_conversion		(int, tree, bool);
 extern tree type_promotes_to			(tree);

^ permalink raw reply	[flat|nested] 8+ messages in thread

* Re: [PATCH, c++] Emit the diagnostic messages of convert_to_void
  2010-06-17  8:49 [PATCH, c++] Emit the diagnostic messages of convert_to_void Shujing Zhao
@ 2010-06-17  9:38 ` Shujing Zhao
  2010-06-17 10:21   ` Shujing Zhao
  0 siblings, 1 reply; 8+ messages in thread
From: Shujing Zhao @ 2010-06-17  9:38 UTC (permalink / raw)
  To: Shujing Zhao; +Cc: GCC Patches, Gabriel Dos Reis, Paolo Carlini

On 06/17/2010 04:19 PM, Shujing Zhao wrote:
> Hi,
> 
> This patch is to fix the diagnostic issues of function convert_to_void, 
> just like the previous one.
> Tested on i686-pc-linux-gnu with no regression.
> Is it ok for trunk?
> 
> Thanks
> Pearly
> 
Sorry, send the wrong patch.

^ permalink raw reply	[flat|nested] 8+ messages in thread

* Re: [PATCH, c++] Emit the diagnostic messages of convert_to_void
  2010-06-17  9:38 ` Shujing Zhao
@ 2010-06-17 10:21   ` Shujing Zhao
  2010-06-17 10:35     ` Shujing Zhao
  0 siblings, 1 reply; 8+ messages in thread
From: Shujing Zhao @ 2010-06-17 10:21 UTC (permalink / raw)
  To: GCC Patches; +Cc: Gabriel Dos Reis, Paolo Carlini

[-- Attachment #1: Type: text/plain, Size: 398 bytes --]

On 06/17/2010 04:47 PM, Shujing Zhao wrote:
> On 06/17/2010 04:19 PM, Shujing Zhao wrote:
>> Hi,
>>
>> This patch is to fix the diagnostic issues of function 
>> convert_to_void, just like the previous one.
>> Tested on i686-pc-linux-gnu with no regression.
>> Is it ok for trunk?
>>
>> Thanks
>> Pearly
>>
> Sorry, send the wrong patch.

Sorry, the attached patch is the right one.

Thanks
Pearly

[-- Attachment #2: ChangeLog --]
[-- Type: text/plain, Size: 333 bytes --]

2010-06-17  Shujing Zhao  <pearly.zhao@oracle.com>

	* cp-tree.h (impl_conv_void): New type.
	(convert_to_void): Adjust prototype.
	* cvt.c (convert_to_void): Use impl_conv_void and emit the diagnostic
	for easy translation. Change caller.
	* typeck.c: Update call to convert_to_void.
	* semantics.c: Likewise.
	* init.c: Likewise.


[-- Attachment #3: diagnostic.patch --]
[-- Type: text/x-patch, Size: 17070 bytes --]

Index: typeck.c
===================================================================
--- typeck.c	(revision 160889)
+++ typeck.c	(working copy)
@@ -5589,7 +5589,7 @@ build_compound_expr (location_t loc ATTR
 tree
 cp_build_compound_expr (tree lhs, tree rhs, tsubst_flags_t complain)
 {
-  lhs = convert_to_void (lhs, "left-hand operand of comma", complain);
+  lhs = convert_to_void (lhs, ICV_LEFT_OF_COMMA, complain);
 
   if (lhs == error_mark_node || rhs == error_mark_node)
     return error_mark_node;
@@ -5856,7 +5856,7 @@ build_static_cast_1 (tree type, tree exp
 
      Any expression can be explicitly converted to type cv void.  */
   if (TREE_CODE (type) == VOID_TYPE)
-    return convert_to_void (expr, /*implicit=*/NULL, complain);
+    return convert_to_void (expr, ICV_NULL, complain);
 
   /* [expr.static.cast]
 
Index: init.c
===================================================================
--- init.c	(revision 160889)
+++ init.c	(working copy)
@@ -1375,7 +1375,7 @@ expand_default_init (tree binfo, tree tr
     release_tree_vector (parms);
 
   if (TREE_SIDE_EFFECTS (rval))
-    finish_expr_stmt (convert_to_void (rval, NULL, complain));
+    finish_expr_stmt (convert_to_void (rval, ICV_NULL, complain));
 }
 
 /* This function is responsible for initializing EXP with INIT
@@ -2718,7 +2718,7 @@ build_vec_delete_1 (tree base, tree maxi
     /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR.  */
     body = build2 (COMPOUND_EXPR, void_type_node, base, body);
 
-  return convert_to_void (body, /*implicit=*/NULL, tf_warning_or_error);
+  return convert_to_void (body, ICV_NULL, tf_warning_or_error);
 }
 
 /* Create an unnamed variable of the indicated TYPE.  */
Index: semantics.c
===================================================================
--- semantics.c	(revision 160889)
+++ semantics.c	(working copy)
@@ -608,10 +608,10 @@ finish_expr_stmt (tree expr)
 	{
 	  if (warn_sequence_point)
 	    verify_sequence_points (expr);
-	  expr = convert_to_void (expr, "statement", tf_warning_or_error);
+	  expr = convert_to_void (expr, ICV_STATEMENT, tf_warning_or_error);
 	}
       else if (!type_dependent_expression_p (expr))
-	convert_to_void (build_non_dependent_expr (expr), "statement", 
+	convert_to_void (build_non_dependent_expr (expr), ICV_STATEMENT, 
                          tf_warning_or_error);
 
       if (check_for_bare_parameter_packs (expr))
@@ -869,11 +869,11 @@ finish_for_expr (tree expr, tree for_stm
     {
       if (warn_sequence_point)
 	verify_sequence_points (expr);
-      expr = convert_to_void (expr, "3rd expression in for",
+      expr = convert_to_void (expr, ICV_THIRD_IN_FOR,
                               tf_warning_or_error);
     }
   else if (!type_dependent_expression_p (expr))
-    convert_to_void (build_non_dependent_expr (expr), "3rd expression in for",
+    convert_to_void (build_non_dependent_expr (expr), ICV_THIRD_IN_FOR,
                      tf_warning_or_error);
   expr = maybe_cleanup_point_expr_void (expr);
   if (check_for_bare_parameter_packs (expr))
Index: cvt.c
===================================================================
--- cvt.c	(revision 160889)
+++ cvt.c	(working copy)
@@ -651,7 +651,7 @@ ocp_convert (tree type, tree expr, int c
 
   if (code == VOID_TYPE && (convtype & CONV_STATIC))
     {
-      e = convert_to_void (e, /*implicit=*/NULL, tf_warning_or_error);
+      e = convert_to_void (e, ICV_NULL, tf_warning_or_error);
       return e;
     }
 
@@ -814,19 +814,18 @@ ocp_convert (tree type, tree expr, int c
    make it impossible to ignore the reference return value from functions. We
    issue warnings in the confusing cases.
 
-   IMPLICIT is non-NULL iff an expression is being implicitly converted; it
-   is NULL when the user is explicitly converting an expression to void via
-   a cast.  When non-NULL, IMPLICIT is a string indicating the context of
-   the implicit conversion.  */
+   The IMPLICIT is ICV_NULL when the user is explicitly converting an expression
+   to void via a cast. If an expression is being implicitly converted, IMPLICIT
+   indicates the context of the implicit conversion.  */
 
 tree
-convert_to_void (tree expr, const char *implicit, tsubst_flags_t complain)
+convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain)
 {
   if (expr == error_mark_node
       || TREE_TYPE (expr) == error_mark_node)
     return error_mark_node;
 
-  if (implicit == NULL)
+  if (implicit == ICV_NULL)
     mark_exp_read (expr);
   else
     {
@@ -865,12 +864,17 @@ convert_to_void (tree expr, const char *
 	tree op1 = TREE_OPERAND (expr,1);
 	tree op2 = TREE_OPERAND (expr,2);
 	bool side_effects = TREE_SIDE_EFFECTS (op1) || TREE_SIDE_EFFECTS (op2);
-	tree new_op1 = convert_to_void
-	  (op1, (implicit && !side_effects
-		 ? "second operand of conditional" : NULL), complain);
-	tree new_op2 = convert_to_void
-	  (op2, (implicit && !side_effects
-		 ? "third operand of conditional" : NULL), complain);
+	tree new_op1, new_op2;
+	if (implicit != ICV_NULL && !side_effects)
+	  {
+	    new_op1 = convert_to_void (op1, ICV_SECOND_OF_COND, complain);
+	    new_op2 = convert_to_void (op2, ICV_THIRD_OF_COND, complain);
+	  }
+	else
+	  {
+	    new_op1 = convert_to_void (op1, ICV_NULL, complain);
+	    new_op2 = convert_to_void (op2, ICV_NULL, complain);
+	  }
 
 	expr = build3 (COND_EXPR, TREE_TYPE (new_op1),
 		       TREE_OPERAND (expr, 0), new_op1, new_op2);
@@ -881,9 +885,11 @@ convert_to_void (tree expr, const char *
       {
 	/* The second part of a compound expr contains the value.  */
 	tree op1 = TREE_OPERAND (expr,1);
-	tree new_op1 = convert_to_void
-	  (op1, (implicit && !TREE_NO_WARNING (expr)
-		 ? "right-hand operand of comma" : NULL), complain);
+	tree new_op1;
+	if (implicit != ICV_NULL && !TREE_NO_WARNING (expr))
+	  new_op1 = convert_to_void (op1, ICV_RIGHT_OF_COMMA, complain);
+	else
+	  new_op1 = convert_to_void (op1, ICV_NULL, complain);
 
 	if (new_op1 != op1)
 	  {
@@ -915,17 +921,88 @@ convert_to_void (tree expr, const char *
 	if (is_volatile && !is_complete)
           {
             if (complain & tf_warning)
-              warning (0, "object of incomplete type %qT will not be accessed in %s",
-                       type, implicit ? implicit : "void context");
+	      switch (implicit)
+		{
+	      	  case ICV_NULL:
+		    warning (0, "object of incomplete type %qT will not "
+			    	"be accessed in void context", type);
+		    break;
+		  case ICV_SECOND_OF_COND:
+		    warning (0, "object of incomplete type %qT will not "
+		    		"be accessed in second operand of conditional",
+			     type);
+		    break;
+		  case ICV_THIRD_OF_COND:
+		    warning (0, "object of incomplete type %qT will not "
+		  	      	"be accessed in third operand of conditional",
+			     type);
+		    break;
+		  case ICV_RIGHT_OF_COMMA:
+		    warning (0, "object of incomplete type %qT will not "
+		    		"be accessed in right-hand operand of comma",
+			     type);
+		    break;
+		  case ICV_LEFT_OF_COMMA:
+		    warning (0, "object of incomplete type %qT will not "
+		    		"be accessed in left-hand operand of comma",
+			     type);
+		    break;
+		  case ICV_STATEMENT:
+		     warning (0, "object of incomplete type %qT will not "
+		     		 "be accessed in statement",  type);
+		     break;
+		  case ICV_THIRD_IN_FOR:
+		    warning (0, "object of incomplete type %qT will not "
+		    		"be accessed in 3rd expression in for ",
+			     type);
+		    break;
+		  default:
+		    gcc_unreachable ();
+		}
           }
 	/* Don't load the value if this is an implicit dereference, or if
 	   the type needs to be handled by ctors/dtors.  */
 	else if (is_volatile && (is_reference || TREE_ADDRESSABLE (type)))
           {
             if (complain & tf_warning)
-              warning (0, "object of type %qT will not be accessed in %s",
-                       TREE_TYPE (TREE_OPERAND (expr, 0)),
-                       implicit ? implicit : "void context");
+	      switch (implicit)
+		{
+	      	  case ICV_NULL:
+		    warning (0, "object of type %qT will not "
+			    	"be accessed in void context", type);
+		    break;
+		  case ICV_SECOND_OF_COND:
+		    warning (0, "object of type %qT will not "
+		    		"be accessed in second operand of conditional",
+			     type);
+		    break;
+		  case ICV_THIRD_OF_COND:
+		    warning (0, "object of type %qT will not "
+		  	      	"be accessed in third operand of conditional",
+			     type);
+		    break;
+		  case ICV_RIGHT_OF_COMMA:
+		    warning (0, "object of type %qT will not "
+		    		"be accessed in right-hand operand of comma",
+			     type);
+		    break;
+		  case ICV_LEFT_OF_COMMA:
+		    warning (0, "object of type %qT will not "
+		    		"be accessed in left-hand operand of comma",
+			     type);
+		    break;
+		  case ICV_STATEMENT:
+		     warning (0, "object of type %qT will not "
+		     		 "be accessed in statement",  type);
+		     break;
+		  case ICV_THIRD_IN_FOR:
+		    warning (0, "object of type %qT will not "
+		    		"be accessed in 3rd expression in for ",
+			     type);
+		    break;
+		  default:
+		    gcc_unreachable ();
+		}
           }
 	if (is_reference || !is_volatile || !is_complete || TREE_ADDRESSABLE (type))
           {
@@ -936,7 +1013,7 @@ convert_to_void (tree expr, const char *
                - automatic dereferencing of references, since the user cannot
                  control it. (See also warn_if_unused_value() in stmt.c.)  */
             if (warn_unused_value
-		&& implicit
+		&& implicit != ICV_NULL
                 && (complain & tf_warning)
                 && !TREE_NO_WARNING (expr)
                 && !is_reference)
@@ -954,8 +1031,45 @@ convert_to_void (tree expr, const char *
 	int is_complete = COMPLETE_TYPE_P (complete_type (type));
 
 	if (TYPE_VOLATILE (type) && !is_complete && (complain & tf_warning))
-	  warning (0, "object %qE of incomplete type %qT will not be accessed in %s",
-		   expr, type, implicit ? implicit : "void context");
+	  switch (implicit)
+	    {
+	      case ICV_NULL:
+		warning (0, "object %qE of incomplete type %qT will not "
+			    "be accessed in void context", expr, type);
+		break;
+	      case ICV_SECOND_OF_COND:
+	        warning (0, "object %qE of incomplete type %qT will not "
+			    "be accessed in second operand of conditional",
+			 expr, type);
+		break;
+	      case ICV_THIRD_OF_COND:
+	        warning (0, "object %qE of incomplete type %qT will not "
+			    "be accessed in third operand of conditional",
+			 expr, type);
+		break;
+	      case ICV_RIGHT_OF_COMMA:
+	        warning (0, "object %qE of incomplete type %qT will not "
+			    "be accessed in right-hand operand of comma",
+			 expr, type);
+		break;
+	      case ICV_LEFT_OF_COMMA:
+	        warning (0, "object %qE of incomplete type %qT will not "
+			    "be accessed in left-hand operand of comma",
+			 expr, type);
+		break;
+	      case ICV_STATEMENT:
+	        warning (0, "object %qE of incomplete type %qT will not "
+		            "be accessed in statement", expr, type);
+		break;
+	      case ICV_THIRD_IN_FOR:
+	        warning (0, "object %qE of incomplete type %qT will not "
+			    "be accessed in 3rd expression in for ",
+		         expr, type);
+		break;
+	      default:
+	        gcc_unreachable ();
+	    }
+
 	break;
       }
 
@@ -994,18 +1108,81 @@ convert_to_void (tree expr, const char *
 	/* [over.over] enumerates the places where we can take the address
 	   of an overloaded function, and this is not one of them.  */
 	if (complain & tf_error)
-	  error ("%s cannot resolve address of overloaded function",
-		 implicit ? implicit : "void cast");
+	  switch (implicit)
+	    {
+	      case ICV_NULL:
+		error ("void cast "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_SECOND_OF_COND:
+		error ("second operand of conditional "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_THIRD_OF_COND:
+		error ("third operand of conditional "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_RIGHT_OF_COMMA:
+		error ("right-hand operand of comma "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_LEFT_OF_COMMA:
+		error ("left-hand operand of comma "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_STATEMENT:
+		error ("statement "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_THIRD_IN_FOR:
+		error ("3rd expression in for "
+		       "cannot resolve address of overloaded function");
+		break;
+	    }
 	else
 	  return error_mark_node;
 	expr = void_zero_node;
       }
-    else if (implicit && probe == expr && is_overloaded_fn (probe))
+    else if (implicit != IRC_NULL && probe == expr && is_overloaded_fn (probe))
       {
 	/* Only warn when there is no &.  */
 	if (complain & tf_warning)
-	  warning (OPT_Waddress, "%s is a reference, not call, to function %qE",
-		   implicit, expr);
+	  switch (implicit)
+	    {
+	      case ICV_SECOND_OF_COND:
+	        warning (OPT_Waddress,
+			 "second operand of conditional "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      case ICV_THIRD_OF_COND:
+	        warning (OPT_Waddress,
+			 "third operand of conditional "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      case ICV_RIGHT_OF_COMMA:
+	        warning (OPT_Waddress,
+			 "right-hand operand of comma "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      case ICV_LEFT_OF_COMMA:
+	        warning (OPT_Waddress,
+			 "left-hand operand of comma "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      case ICV_STATEMENT:
+	        warning (OPT_Waddress,
+			 "statement "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      case ICV_THIRD_IN_FOR:
+	        warning (OPT_Waddress,
+			 "3rd expression in for "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      default:
+	        gcc_unreachable ();
+	    }
+
 	if (TREE_CODE (expr) == COMPONENT_REF)
 	  expr = TREE_OPERAND (expr, 0);
       }
@@ -1013,7 +1190,7 @@ convert_to_void (tree expr, const char *
 
   if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr)))
     {
-      if (implicit
+      if (implicit != ICV_NULL
 	  && warn_unused_value
 	  && !TREE_NO_WARNING (expr)
 	  && !processing_template_decl)
@@ -1022,7 +1199,35 @@ convert_to_void (tree expr, const char *
 	     been explicitly cast to void, so we must do so here.  */
 	  if (!TREE_SIDE_EFFECTS (expr)) {
             if (complain & tf_warning)
-              warning (OPT_Wunused_value, "%s has no effect", implicit);
+	      switch (implicit)
+		{
+		  case ICV_SECOND_OF_COND:
+		    warning (OPT_Wunused_value,
+			     "second operand of conditional has no effect");
+		    break;
+		  case ICV_THIRD_OF_COND:
+		    warning (OPT_Wunused_value,
+		    	     "third operand of conditional has no effect");
+		    break;
+		  case ICV_RIGHT_OF_COMMA:
+		    warning (OPT_Wunused_value,
+		    	     "right-hand operand of comma has no effect");
+		    break;
+		  case ICV_LEFT_OF_COMMA:
+		    warning (OPT_Wunused_value,
+		    	     "left-hand operand of comma has no effect");
+		    break;
+		  case ICV_STATEMENT:
+		    warning (OPT_Wunused_value,
+		    	     "statement has no effect");
+		    break;
+		  case ICV_THIRD_IN_FOR:
+		    warning (OPT_Wunused_value,
+		    	     "3rd expression in for has no effect");
+		    break;
+		  default:
+		    gcc_unreachable ();
+		}
           }
 	  else
 	    {
Index: cp-tree.h
===================================================================
--- cp-tree.h	(revision 160889)
+++ cp-tree.h	(working copy)
@@ -435,6 +435,17 @@ typedef enum impl_conv_rhs {
   ICR_ASSIGN            /* assignment */
 } impl_conv_rhs;
 
+/* Possible cases of implicit or explicit bad conversions to void. */
+typedef enum impl_conv_void {
+  ICV_NULL,		/* NULL */
+  ICV_SECOND_OF_COND,	/* second operand of conditional */
+  ICV_THIRD_OF_COND,	/* third operand of conditional */
+  ICV_RIGHT_OF_COMMA,	/* right-hand operand of comma */
+  ICV_LEFT_OF_COMMA,	/* left-hand operand of comma */
+  ICV_STATEMENT,	/* statement */
+  ICV_THIRD_IN_FOR	/* 3rd expression in for */
+} impl_conv_void;
+
 /* Macros for access to language-specific slots in an identifier.  */
 
 #define IDENTIFIER_NAMESPACE_BINDINGS(NODE)	\
@@ -4669,8 +4680,8 @@ extern tree ocp_convert				(tree, tree, 
 extern tree cp_convert				(tree, tree);
 extern tree cp_convert_and_check                (tree, tree);
 extern tree cp_fold_convert			(tree, tree);
-extern tree convert_to_void	(tree, const char */*implicit context*/,
-                                 tsubst_flags_t);
+extern tree convert_to_void			(tree, impl_conv_void,
+						 tsubst_flags_t);
 extern tree convert_force			(tree, tree, int);
 extern tree build_expr_type_conversion		(int, tree, bool);
 extern tree type_promotes_to			(tree);

^ permalink raw reply	[flat|nested] 8+ messages in thread

* Re: [PATCH, c++] Emit the diagnostic messages of convert_to_void
  2010-06-17 10:21   ` Shujing Zhao
@ 2010-06-17 10:35     ` Shujing Zhao
  2010-07-01  6:28       ` Shujing Zhao
  2010-07-02 20:15       ` Jason Merrill
  0 siblings, 2 replies; 8+ messages in thread
From: Shujing Zhao @ 2010-06-17 10:35 UTC (permalink / raw)
  To: GCC Patches; +Cc: Gabriel Dos Reis, Paolo Carlini

[-- Attachment #1: Type: text/plain, Size: 499 bytes --]

On 06/17/2010 05:45 PM, Shujing Zhao wrote:
> On 06/17/2010 04:47 PM, Shujing Zhao wrote:
>> On 06/17/2010 04:19 PM, Shujing Zhao wrote:
>>> Hi,
>>>
>>> This patch is to fix the diagnostic issues of function 
>>> convert_to_void, just like the previous one.
>>> Tested on i686-pc-linux-gnu with no regression.
>>> Is it ok for trunk?
>>>
>>> Thanks
>>> Pearly
>>>
>> Sorry, send the wrong patch.
> 
> Sorry, the attached patch is the right one.
> 

I'm so sorry to send the patch again and again.



[-- Attachment #2: diagnostic.patch --]
[-- Type: text/x-patch, Size: 16356 bytes --]

Index: typeck.c
===================================================================
--- typeck.c	(revision 160871)
+++ typeck.c	(working copy)
@@ -5589,7 +5589,7 @@
 tree
 cp_build_compound_expr (tree lhs, tree rhs, tsubst_flags_t complain)
 {
-  lhs = convert_to_void (lhs, "left-hand operand of comma", complain);
+  lhs = convert_to_void (lhs, ICV_LEFT_OF_COMMA, complain);
 
   if (lhs == error_mark_node || rhs == error_mark_node)
     return error_mark_node;
@@ -5856,7 +5856,7 @@
 
      Any expression can be explicitly converted to type cv void.  */
   if (TREE_CODE (type) == VOID_TYPE)
-    return convert_to_void (expr, /*implicit=*/NULL, complain);
+    return convert_to_void (expr, ICV_NULL, complain);
 
   /* [expr.static.cast]
 
Index: init.c
===================================================================
--- init.c	(revision 160871)
+++ init.c	(working copy)
@@ -1375,7 +1375,7 @@
     release_tree_vector (parms);
 
   if (TREE_SIDE_EFFECTS (rval))
-    finish_expr_stmt (convert_to_void (rval, NULL, complain));
+    finish_expr_stmt (convert_to_void (rval, ICV_NULL, complain));
 }
 
 /* This function is responsible for initializing EXP with INIT
@@ -2718,7 +2718,7 @@
     /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR.  */
     body = build2 (COMPOUND_EXPR, void_type_node, base, body);
 
-  return convert_to_void (body, /*implicit=*/NULL, tf_warning_or_error);
+  return convert_to_void (body, ICV_NULL, tf_warning_or_error);
 }
 
 /* Create an unnamed variable of the indicated TYPE.  */
Index: semantics.c
===================================================================
--- semantics.c	(revision 160871)
+++ semantics.c	(working copy)
@@ -608,10 +608,10 @@
 	{
 	  if (warn_sequence_point)
 	    verify_sequence_points (expr);
-	  expr = convert_to_void (expr, "statement", tf_warning_or_error);
+	  expr = convert_to_void (expr, ICV_STATEMENT, tf_warning_or_error);
 	}
       else if (!type_dependent_expression_p (expr))
-	convert_to_void (build_non_dependent_expr (expr), "statement", 
+	convert_to_void (build_non_dependent_expr (expr), ICV_STATEMENT, 
                          tf_warning_or_error);
 
       if (check_for_bare_parameter_packs (expr))
@@ -869,11 +869,11 @@
     {
       if (warn_sequence_point)
 	verify_sequence_points (expr);
-      expr = convert_to_void (expr, "3rd expression in for",
+      expr = convert_to_void (expr, ICV_THIRD_IN_FOR,
                               tf_warning_or_error);
     }
   else if (!type_dependent_expression_p (expr))
-    convert_to_void (build_non_dependent_expr (expr), "3rd expression in for",
+    convert_to_void (build_non_dependent_expr (expr), ICV_THIRD_IN_FOR,
                      tf_warning_or_error);
   expr = maybe_cleanup_point_expr_void (expr);
   if (check_for_bare_parameter_packs (expr))
Index: cvt.c
===================================================================
--- cvt.c	(revision 160871)
+++ cvt.c	(working copy)
@@ -651,7 +651,7 @@
 
   if (code == VOID_TYPE && (convtype & CONV_STATIC))
     {
-      e = convert_to_void (e, /*implicit=*/NULL, tf_warning_or_error);
+      e = convert_to_void (e, ICV_NULL, tf_warning_or_error);
       return e;
     }
 
@@ -814,19 +814,18 @@
    make it impossible to ignore the reference return value from functions. We
    issue warnings in the confusing cases.
 
-   IMPLICIT is non-NULL iff an expression is being implicitly converted; it
-   is NULL when the user is explicitly converting an expression to void via
-   a cast.  When non-NULL, IMPLICIT is a string indicating the context of
-   the implicit conversion.  */
+   The IMPLICIT is ICV_NULL when the user is explicitly converting an expression
+   to void via a cast. If an expression is being implicitly converted, IMPLICIT
+   indicates the context of the implicit conversion.  */
 
 tree
-convert_to_void (tree expr, const char *implicit, tsubst_flags_t complain)
+convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain)
 {
   if (expr == error_mark_node
       || TREE_TYPE (expr) == error_mark_node)
     return error_mark_node;
 
-  if (implicit == NULL)
+  if (implicit == ICV_NULL)
     mark_exp_read (expr);
   else
     {
@@ -865,12 +864,17 @@
 	tree op1 = TREE_OPERAND (expr,1);
 	tree op2 = TREE_OPERAND (expr,2);
 	bool side_effects = TREE_SIDE_EFFECTS (op1) || TREE_SIDE_EFFECTS (op2);
-	tree new_op1 = convert_to_void
-	  (op1, (implicit && !side_effects
-		 ? "second operand of conditional" : NULL), complain);
-	tree new_op2 = convert_to_void
-	  (op2, (implicit && !side_effects
-		 ? "third operand of conditional" : NULL), complain);
+	tree new_op1, new_op2;
+	if (implicit != ICV_NULL && !side_effects)
+	  {
+	    new_op1 = convert_to_void (op1, ICV_SECOND_OF_COND, complain);
+	    new_op2 = convert_to_void (op2, ICV_THIRD_OF_COND, complain);
+	  }
+	else
+	  {
+	    new_op1 = convert_to_void (op1, ICV_NULL, complain);
+	    new_op2 = convert_to_void (op2, ICV_NULL, complain);
+	  }
 
 	expr = build3 (COND_EXPR, TREE_TYPE (new_op1),
 		       TREE_OPERAND (expr, 0), new_op1, new_op2);
@@ -881,9 +885,11 @@
       {
 	/* The second part of a compound expr contains the value.  */
 	tree op1 = TREE_OPERAND (expr,1);
-	tree new_op1 = convert_to_void
-	  (op1, (implicit && !TREE_NO_WARNING (expr)
-		 ? "right-hand operand of comma" : NULL), complain);
+	tree new_op1;
+	if (implicit != ICV_NULL && !TREE_NO_WARNING (expr))
+	  new_op1 = convert_to_void (op1, ICV_RIGHT_OF_COMMA, complain);
+	else
+	  new_op1 = convert_to_void (op1, ICV_NULL, complain);
 
 	if (new_op1 != op1)
 	  {
@@ -915,17 +921,88 @@
 	if (is_volatile && !is_complete)
           {
             if (complain & tf_warning)
-              warning (0, "object of incomplete type %qT will not be accessed in %s",
-                       type, implicit ? implicit : "void context");
+	      switch (implicit)
+		{
+	      	  case ICV_NULL:
+		    warning (0, "object of incomplete type %qT will not "
+			    	"be accessed in void context", type);
+		    break;
+		  case ICV_SECOND_OF_COND:
+		    warning (0, "object of incomplete type %qT will not "
+		    		"be accessed in second operand of conditional",
+			     type);
+		    break;
+		  case ICV_THIRD_OF_COND:
+		    warning (0, "object of incomplete type %qT will not "
+		  	      	"be accessed in third operand of conditional",
+			     type);
+		    break;
+		  case ICV_RIGHT_OF_COMMA:
+		    warning (0, "object of incomplete type %qT will not "
+		    		"be accessed in right-hand operand of comma",
+			     type);
+		    break;
+		  case ICV_LEFT_OF_COMMA:
+		    warning (0, "object of incomplete type %qT will not "
+		    		"be accessed in left-hand operand of comma",
+			     type);
+		    break;
+		  case ICV_STATEMENT:
+		     warning (0, "object of incomplete type %qT will not "
+		     		 "be accessed in statement",  type);
+		     break;
+		  case ICV_THIRD_IN_FOR:
+		    warning (0, "object of incomplete type %qT will not "
+		    		"be accessed in 3rd expression in for ",
+			     type);
+		    break;
+		  default:
+		    gcc_unreachable ();
+		}
           }
 	/* Don't load the value if this is an implicit dereference, or if
 	   the type needs to be handled by ctors/dtors.  */
 	else if (is_volatile && (is_reference || TREE_ADDRESSABLE (type)))
           {
             if (complain & tf_warning)
-              warning (0, "object of type %qT will not be accessed in %s",
-                       TREE_TYPE (TREE_OPERAND (expr, 0)),
-                       implicit ? implicit : "void context");
+	      switch (implicit)
+		{
+	      	  case ICV_NULL:
+		    warning (0, "object of type %qT will not "
+			    	"be accessed in void context", type);
+		    break;
+		  case ICV_SECOND_OF_COND:
+		    warning (0, "object of type %qT will not "
+		    		"be accessed in second operand of conditional",
+			     type);
+		    break;
+		  case ICV_THIRD_OF_COND:
+		    warning (0, "object of type %qT will not "
+		  	      	"be accessed in third operand of conditional",
+			     type);
+		    break;
+		  case ICV_RIGHT_OF_COMMA:
+		    warning (0, "object of type %qT will not "
+		    		"be accessed in right-hand operand of comma",
+			     type);
+		    break;
+		  case ICV_LEFT_OF_COMMA:
+		    warning (0, "object of type %qT will not "
+		    		"be accessed in left-hand operand of comma",
+			     type);
+		    break;
+		  case ICV_STATEMENT:
+		     warning (0, "object of type %qT will not "
+		     		 "be accessed in statement",  type);
+		     break;
+		  case ICV_THIRD_IN_FOR:
+		    warning (0, "object of type %qT will not "
+		    		"be accessed in 3rd expression in for ",
+			     type);
+		    break;
+		  default:
+		    gcc_unreachable ();
+		}
           }
 	if (is_reference || !is_volatile || !is_complete || TREE_ADDRESSABLE (type))
           {
@@ -936,7 +1013,7 @@
                - automatic dereferencing of references, since the user cannot
                  control it. (See also warn_if_unused_value() in stmt.c.)  */
             if (warn_unused_value
-		&& implicit
+		&& implicit != ICV_NULL
                 && (complain & tf_warning)
                 && !TREE_NO_WARNING (expr)
                 && !is_reference)
@@ -954,8 +1031,45 @@
 	int is_complete = COMPLETE_TYPE_P (complete_type (type));
 
 	if (TYPE_VOLATILE (type) && !is_complete && (complain & tf_warning))
-	  warning (0, "object %qE of incomplete type %qT will not be accessed in %s",
-		   expr, type, implicit ? implicit : "void context");
+	  switch (implicit)
+	    {
+	      case ICV_NULL:
+		warning (0, "object %qE of incomplete type %qT will not "
+			    "be accessed in void context", expr, type);
+		break;
+	      case ICV_SECOND_OF_COND:
+	        warning (0, "object %qE of incomplete type %qT will not "
+			    "be accessed in second operand of conditional",
+			 expr, type);
+		break;
+	      case ICV_THIRD_OF_COND:
+	        warning (0, "object %qE of incomplete type %qT will not "
+			    "be accessed in third operand of conditional",
+			 expr, type);
+		break;
+	      case ICV_RIGHT_OF_COMMA:
+	        warning (0, "object %qE of incomplete type %qT will not "
+			    "be accessed in right-hand operand of comma",
+			 expr, type);
+		break;
+	      case ICV_LEFT_OF_COMMA:
+	        warning (0, "object %qE of incomplete type %qT will not "
+			    "be accessed in left-hand operand of comma",
+			 expr, type);
+		break;
+	      case ICV_STATEMENT:
+	        warning (0, "object %qE of incomplete type %qT will not "
+		            "be accessed in statement", expr, type);
+		break;
+	      case ICV_THIRD_IN_FOR:
+	        warning (0, "object %qE of incomplete type %qT will not "
+			    "be accessed in 3rd expression in for ",
+		         expr, type);
+		break;
+	      default:
+	        gcc_unreachable ();
+	    }
+
 	break;
       }
 
@@ -994,18 +1108,81 @@
 	/* [over.over] enumerates the places where we can take the address
 	   of an overloaded function, and this is not one of them.  */
 	if (complain & tf_error)
-	  error ("%s cannot resolve address of overloaded function",
-		 implicit ? implicit : "void cast");
+	  switch (implicit)
+	    {
+	      case ICV_NULL:
+		error ("void cast "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_SECOND_OF_COND:
+		error ("second operand of conditional "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_THIRD_OF_COND:
+		error ("third operand of conditional "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_RIGHT_OF_COMMA:
+		error ("right-hand operand of comma "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_LEFT_OF_COMMA:
+		error ("left-hand operand of comma "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_STATEMENT:
+		error ("statement "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_THIRD_IN_FOR:
+		error ("3rd expression in for "
+		       "cannot resolve address of overloaded function");
+		break;
+	    }
 	else
 	  return error_mark_node;
 	expr = void_zero_node;
       }
-    else if (implicit && probe == expr && is_overloaded_fn (probe))
+    else if (implicit != ICV_NULL && probe == expr && is_overloaded_fn (probe))
       {
 	/* Only warn when there is no &.  */
 	if (complain & tf_warning)
-	  warning (OPT_Waddress, "%s is a reference, not call, to function %qE",
-		   implicit, expr);
+	  switch (implicit)
+	    {
+	      case ICV_SECOND_OF_COND:
+	        warning (OPT_Waddress,
+			 "second operand of conditional "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      case ICV_THIRD_OF_COND:
+	        warning (OPT_Waddress,
+			 "third operand of conditional "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      case ICV_RIGHT_OF_COMMA:
+	        warning (OPT_Waddress,
+			 "right-hand operand of comma "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      case ICV_LEFT_OF_COMMA:
+	        warning (OPT_Waddress,
+			 "left-hand operand of comma "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      case ICV_STATEMENT:
+	        warning (OPT_Waddress,
+			 "statement "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      case ICV_THIRD_IN_FOR:
+	        warning (OPT_Waddress,
+			 "3rd expression in for "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      default:
+	        gcc_unreachable ();
+	    }
+
 	if (TREE_CODE (expr) == COMPONENT_REF)
 	  expr = TREE_OPERAND (expr, 0);
       }
@@ -1013,7 +1190,7 @@
 
   if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr)))
     {
-      if (implicit
+      if (implicit != ICV_NULL
 	  && warn_unused_value
 	  && !TREE_NO_WARNING (expr)
 	  && !processing_template_decl)
@@ -1022,7 +1199,35 @@
 	     been explicitly cast to void, so we must do so here.  */
 	  if (!TREE_SIDE_EFFECTS (expr)) {
             if (complain & tf_warning)
-              warning (OPT_Wunused_value, "%s has no effect", implicit);
+	      switch (implicit)
+		{
+		  case ICV_SECOND_OF_COND:
+		    warning (OPT_Wunused_value,
+			     "second operand of conditional has no effect");
+		    break;
+		  case ICV_THIRD_OF_COND:
+		    warning (OPT_Wunused_value,
+		    	     "third operand of conditional has no effect");
+		    break;
+		  case ICV_RIGHT_OF_COMMA:
+		    warning (OPT_Wunused_value,
+		    	     "right-hand operand of comma has no effect");
+		    break;
+		  case ICV_LEFT_OF_COMMA:
+		    warning (OPT_Wunused_value,
+		    	     "left-hand operand of comma has no effect");
+		    break;
+		  case ICV_STATEMENT:
+		    warning (OPT_Wunused_value,
+		    	     "statement has no effect");
+		    break;
+		  case ICV_THIRD_IN_FOR:
+		    warning (OPT_Wunused_value,
+		    	     "3rd expression in for has no effect");
+		    break;
+		  default:
+		    gcc_unreachable ();
+		}
           }
 	  else
 	    {
Index: cp-tree.h
===================================================================
--- cp-tree.h	(revision 160871)
+++ cp-tree.h	(working copy)
@@ -435,6 +435,17 @@
   ICR_ASSIGN            /* assignment */
 } impl_conv_rhs;
 
+/* Possible cases of implicit or explicit bad conversions to void. */
+typedef enum impl_conv_void {
+  ICV_NULL,		/* NULL */
+  ICV_SECOND_OF_COND,	/* second operand of conditional */
+  ICV_THIRD_OF_COND,	/* third operand of conditional */
+  ICV_RIGHT_OF_COMMA,	/* right-hand operand of comma */
+  ICV_LEFT_OF_COMMA,	/* left-hand operand of comma */
+  ICV_STATEMENT,	/* statement */
+  ICV_THIRD_IN_FOR	/* 3rd expression in for */
+} impl_conv_void;
+
 /* Macros for access to language-specific slots in an identifier.  */
 
 #define IDENTIFIER_NAMESPACE_BINDINGS(NODE)	\
@@ -4669,8 +4680,8 @@
 extern tree cp_convert				(tree, tree);
 extern tree cp_convert_and_check                (tree, tree);
 extern tree cp_fold_convert			(tree, tree);
-extern tree convert_to_void	(tree, const char */*implicit context*/,
-                                 tsubst_flags_t);
+extern tree convert_to_void			(tree, impl_conv_void,
+						 tsubst_flags_t);
 extern tree convert_force			(tree, tree, int);
 extern tree build_expr_type_conversion		(int, tree, bool);
 extern tree type_promotes_to			(tree);

^ permalink raw reply	[flat|nested] 8+ messages in thread

* Re: [PATCH, c++] Emit the diagnostic messages of convert_to_void
  2010-06-17 10:35     ` Shujing Zhao
@ 2010-07-01  6:28       ` Shujing Zhao
  2010-07-02 20:15       ` Jason Merrill
  1 sibling, 0 replies; 8+ messages in thread
From: Shujing Zhao @ 2010-07-01  6:28 UTC (permalink / raw)
  To: GCC Patches; +Cc: Gabriel Dos Reis, Paolo Carlini

On 06/17/2010 05:57 PM, Shujing Zhao wrote:
>>>> Hi,
>>>>
>>>> This patch is to fix the diagnostic issues of function 
>>>> convert_to_void, just like the previous one.
>>>> Tested on i686-pc-linux-gnu with no regression.
>>>> Is it ok for trunk?
>>>>
>>>> Thanks
>>>> Pearly
> 
> I'm so sorry to send the patch again and again.
>  

Retested on current trunk.
Ping~

Regards
Pearly

^ permalink raw reply	[flat|nested] 8+ messages in thread

* Re: [PATCH, c++] Emit the diagnostic messages of convert_to_void
  2010-06-17 10:35     ` Shujing Zhao
  2010-07-01  6:28       ` Shujing Zhao
@ 2010-07-02 20:15       ` Jason Merrill
  2010-07-05 10:05         ` Shujing Zhao
  1 sibling, 1 reply; 8+ messages in thread
From: Jason Merrill @ 2010-07-02 20:15 UTC (permalink / raw)
  To: Shujing Zhao
  Cc: GCC Patches, Gabriel Dos Reis, Paolo Carlini,
	Manuel López-Ibáñez

> +   The IMPLICIT is ICV_NULL when the user is explicitly converting an expression
> +   to void via a cast.

In that case let's call it ICV_CAST.

Let's improve the error messages here, too.

> +		    warning (0, "object of incomplete type %qT will not "
> +			    	"be accessed in void context", type);

"conversion to void will not access object of incomplete type %qT"

(Incidentally, I'm surprised these warnings are unconditional rather 
than being controlled by a -Wvolatile option or something, but I guess 
we can leave that alone for now since volatile is relatively rare.)

> +		    warning (0, "object of incomplete type %qT will not "
> +		    		"be accessed in second operand of conditional",

"indirection will not access object of incomplete type %qT in second 
operand of conditional expression" (or third)

"indirection will not access object of incomplete type %qT in right 
operand of comma operator" (or left)

"indirection will not access object of incomplete type %qT in statement"

"indirection will not access object of incomplete type %qT in for 
increment expression"

>  	/* Don't load the value if this is an implicit dereference, or if
>  	   the type needs to be handled by ctors/dtors.  */
>  	else if (is_volatile && (is_reference || TREE_ADDRESSABLE (type)))

Let's split up these cases.

is_reference:

"conversion to void will not access object of type %qT"

"implicit dereference will not access object of type %qT in..."

TREE_ADDRESSABLE:

"conversion to void will not access object of non-trivially-copyable 
type %qT"

"indirection will not access object of non-trivially-copyable type %qT 
in..."

> +		warning (0, "object %qE of incomplete type %qT will not "
> +			    "be accessed in void context", expr, type);

"conversion to void will not access object %qE of incomplete type %qT"

"variable %qE of incomplete type %qT will not be accessed in..."

> +		error ("void cast "
> +		       "cannot resolve address of overloaded function");

conversion to void, etc.

> +			 "second operand of conditional "
> +			 "is a reference, not call, to function %qE", expr);

conditional expression, etc.

> +		    warning (OPT_Wunused_value,
> +			     "second operand of conditional has no effect");

Likewise.

Jason

^ permalink raw reply	[flat|nested] 8+ messages in thread

* Re: [PATCH, c++] Emit the diagnostic messages of convert_to_void
  2010-07-02 20:15       ` Jason Merrill
@ 2010-07-05 10:05         ` Shujing Zhao
  2010-07-05 19:59           ` Jason Merrill
  0 siblings, 1 reply; 8+ messages in thread
From: Shujing Zhao @ 2010-07-05 10:05 UTC (permalink / raw)
  To: Jason Merrill
  Cc: GCC Patches, Gabriel Dos Reis, Paolo Carlini,
	Manuel López-Ibáñez

[-- Attachment #1: Type: text/plain, Size: 2692 bytes --]

On 07/03/2010 04:14 AM, Jason Merrill wrote:
>> +   The IMPLICIT is ICV_NULL when the user is explicitly converting an 
>> expression
>> +   to void via a cast.
> 
> In that case let's call it ICV_CAST.
> 
> Let's improve the error messages here, too.
> 
>> +            warning (0, "object of incomplete type %qT will not "
>> +                    "be accessed in void context", type);
> 
> "conversion to void will not access object of incomplete type %qT"
> 
> (Incidentally, I'm surprised these warnings are unconditional rather 
> than being controlled by a -Wvolatile option or something, but I guess 
> we can leave that alone for now since volatile is relatively rare.)
> 
>> +            warning (0, "object of incomplete type %qT will not "
>> +                    "be accessed in second operand of conditional",
> 
> "indirection will not access object of incomplete type %qT in second 
> operand of conditional expression" (or third)
> 
> "indirection will not access object of incomplete type %qT in right 
> operand of comma operator" (or left)
> 
> "indirection will not access object of incomplete type %qT in statement"
> 
> "indirection will not access object of incomplete type %qT in for 
> increment expression"
> 
>>      /* Don't load the value if this is an implicit dereference, or if
>>         the type needs to be handled by ctors/dtors.  */
>>      else if (is_volatile && (is_reference || TREE_ADDRESSABLE (type)))
> 
> Let's split up these cases.
> 
> is_reference:
> 
> "conversion to void will not access object of type %qT"
> 
> "implicit dereference will not access object of type %qT in..."
> 
> TREE_ADDRESSABLE:
> 
> "conversion to void will not access object of non-trivially-copyable 
> type %qT"
> 
> "indirection will not access object of non-trivially-copyable type %qT 
> in..."
> 
>> +        warning (0, "object %qE of incomplete type %qT will not "
>> +                "be accessed in void context", expr, type);
> 
> "conversion to void will not access object %qE of incomplete type %qT"
> 
> "variable %qE of incomplete type %qT will not be accessed in..."
> 
>> +        error ("void cast "
>> +               "cannot resolve address of overloaded function");
> 
> conversion to void, etc.
> 
>> +             "second operand of conditional "
>> +             "is a reference, not call, to function %qE", expr);
> 
> conditional expression, etc.
> 
>> +            warning (OPT_Wunused_value,
>> +                 "second operand of conditional has no effect");
> 
> Likewise.
Thanks. Adjust the diagnostic messages and the comments at enum definition.
Some test cases are updated too.
Tested on i686-pc-linux-gnu.
Is it ok?

Regards
Pearly


[-- Attachment #2: ChangeLog --]
[-- Type: text/plain, Size: 549 bytes --]

gcc/cp/
2010-07-05  Shujing Zhao  <pearly.zhao@oracle.com>

	* cp-tree.h (impl_conv_void): New type.
	(convert_to_void): Adjust prototype.
	* cvt.c (convert_to_void): Use impl_conv_void and emit and adjust the
	diagnostic for easy translation. Change caller.
	* typeck.c: Update call to convert_to_void.
	* semantics.c: Likewise.
	* init.c: Likewise.

gcc/testsuite/
2010-07-05  Shujing Zhao  <pearly.zhao@oracle.com>

	* g++.dg/warn/noeffect2.C: Adjust expected warning.
	* g++.dg/warn/volatile1.C: Likewise.
	* g++.dg/template/warn1.C: Likewise.


[-- Attachment #3: cvt.patch --]
[-- Type: text/x-patch, Size: 21002 bytes --]

Index: cp/typeck.c
===================================================================
--- cp/typeck.c	(revision 161363)
+++ cp/typeck.c	(working copy)
@@ -5591,7 +5591,7 @@ build_compound_expr (location_t loc ATTR
 tree
 cp_build_compound_expr (tree lhs, tree rhs, tsubst_flags_t complain)
 {
-  lhs = convert_to_void (lhs, "left-hand operand of comma", complain);
+  lhs = convert_to_void (lhs, ICV_LEFT_OF_COMMA, complain);
 
   if (lhs == error_mark_node || rhs == error_mark_node)
     return error_mark_node;
@@ -5858,7 +5858,7 @@ build_static_cast_1 (tree type, tree exp
 
      Any expression can be explicitly converted to type cv void.  */
   if (TREE_CODE (type) == VOID_TYPE)
-    return convert_to_void (expr, /*implicit=*/NULL, complain);
+    return convert_to_void (expr, ICV_CAST, complain);
 
   /* [expr.static.cast]
 
Index: cp/init.c
===================================================================
--- cp/init.c	(revision 161363)
+++ cp/init.c	(working copy)
@@ -1375,7 +1375,7 @@ expand_default_init (tree binfo, tree tr
     release_tree_vector (parms);
 
   if (TREE_SIDE_EFFECTS (rval))
-    finish_expr_stmt (convert_to_void (rval, NULL, complain));
+    finish_expr_stmt (convert_to_void (rval, ICV_CAST, complain));
 }
 
 /* This function is responsible for initializing EXP with INIT
@@ -2718,7 +2718,7 @@ build_vec_delete_1 (tree base, tree maxi
     /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR.  */
     body = build2 (COMPOUND_EXPR, void_type_node, base, body);
 
-  return convert_to_void (body, /*implicit=*/NULL, tf_warning_or_error);
+  return convert_to_void (body, ICV_CAST, tf_warning_or_error);
 }
 
 /* Create an unnamed variable of the indicated TYPE.  */
Index: cp/semantics.c
===================================================================
--- cp/semantics.c	(revision 161363)
+++ cp/semantics.c	(working copy)
@@ -608,10 +608,10 @@ finish_expr_stmt (tree expr)
 	{
 	  if (warn_sequence_point)
 	    verify_sequence_points (expr);
-	  expr = convert_to_void (expr, "statement", tf_warning_or_error);
+	  expr = convert_to_void (expr, ICV_STATEMENT, tf_warning_or_error);
 	}
       else if (!type_dependent_expression_p (expr))
-	convert_to_void (build_non_dependent_expr (expr), "statement", 
+	convert_to_void (build_non_dependent_expr (expr), ICV_STATEMENT, 
                          tf_warning_or_error);
 
       if (check_for_bare_parameter_packs (expr))
@@ -869,11 +869,11 @@ finish_for_expr (tree expr, tree for_stm
     {
       if (warn_sequence_point)
 	verify_sequence_points (expr);
-      expr = convert_to_void (expr, "3rd expression in for",
+      expr = convert_to_void (expr, ICV_THIRD_IN_FOR,
                               tf_warning_or_error);
     }
   else if (!type_dependent_expression_p (expr))
-    convert_to_void (build_non_dependent_expr (expr), "3rd expression in for",
+    convert_to_void (build_non_dependent_expr (expr), ICV_THIRD_IN_FOR,
                      tf_warning_or_error);
   expr = maybe_cleanup_point_expr_void (expr);
   if (check_for_bare_parameter_packs (expr))
Index: cp/cvt.c
===================================================================
--- cp/cvt.c	(revision 161363)
+++ cp/cvt.c	(working copy)
@@ -651,7 +651,7 @@ ocp_convert (tree type, tree expr, int c
 
   if (code == VOID_TYPE && (convtype & CONV_STATIC))
     {
-      e = convert_to_void (e, /*implicit=*/NULL, tf_warning_or_error);
+      e = convert_to_void (e, ICV_CAST, tf_warning_or_error);
       return e;
     }
 
@@ -814,19 +814,18 @@ ocp_convert (tree type, tree expr, int c
    make it impossible to ignore the reference return value from functions. We
    issue warnings in the confusing cases.
 
-   IMPLICIT is non-NULL iff an expression is being implicitly converted; it
-   is NULL when the user is explicitly converting an expression to void via
-   a cast.  When non-NULL, IMPLICIT is a string indicating the context of
-   the implicit conversion.  */
+   The IMPLICIT is ICV_CAST when the user is explicitly converting an expression
+   to void via a cast. If an expression is being implicitly converted, IMPLICIT
+   indicates the context of the implicit conversion.  */
 
 tree
-convert_to_void (tree expr, const char *implicit, tsubst_flags_t complain)
+convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain)
 {
   if (expr == error_mark_node
       || TREE_TYPE (expr) == error_mark_node)
     return error_mark_node;
 
-  if (implicit == NULL)
+  if (implicit == ICV_CAST)
     mark_exp_read (expr);
   else
     {
@@ -865,12 +864,17 @@ convert_to_void (tree expr, const char *
 	tree op1 = TREE_OPERAND (expr,1);
 	tree op2 = TREE_OPERAND (expr,2);
 	bool side_effects = TREE_SIDE_EFFECTS (op1) || TREE_SIDE_EFFECTS (op2);
-	tree new_op1 = convert_to_void
-	  (op1, (implicit && !side_effects
-		 ? "second operand of conditional" : NULL), complain);
-	tree new_op2 = convert_to_void
-	  (op2, (implicit && !side_effects
-		 ? "third operand of conditional" : NULL), complain);
+	tree new_op1, new_op2;
+	if (implicit != ICV_CAST && !side_effects)
+	  {
+	    new_op1 = convert_to_void (op1, ICV_SECOND_OF_COND, complain);
+	    new_op2 = convert_to_void (op2, ICV_THIRD_OF_COND, complain);
+	  }
+	else
+	  {
+	    new_op1 = convert_to_void (op1, ICV_CAST, complain);
+	    new_op2 = convert_to_void (op2, ICV_CAST, complain);
+	  }
 
 	expr = build3 (COND_EXPR, TREE_TYPE (new_op1),
 		       TREE_OPERAND (expr, 0), new_op1, new_op2);
@@ -881,9 +885,11 @@ convert_to_void (tree expr, const char *
       {
 	/* The second part of a compound expr contains the value.  */
 	tree op1 = TREE_OPERAND (expr,1);
-	tree new_op1 = convert_to_void
-	  (op1, (implicit && !TREE_NO_WARNING (expr)
-		 ? "right-hand operand of comma" : NULL), complain);
+	tree new_op1;
+	if (implicit != ICV_CAST && !TREE_NO_WARNING (expr))
+	  new_op1 = convert_to_void (op1, ICV_RIGHT_OF_COMMA, complain);
+	else
+	  new_op1 = convert_to_void (op1, ICV_CAST, complain);
 
 	if (new_op1 != op1)
 	  {
@@ -915,18 +921,133 @@ convert_to_void (tree expr, const char *
 	if (is_volatile && !is_complete)
           {
             if (complain & tf_warning)
-              warning (0, "object of incomplete type %qT will not be accessed in %s",
-                       type, implicit ? implicit : "void context");
+	      switch (implicit)
+		{
+	      	  case ICV_CAST:
+		    warning (0, "conversion to void will not access "
+				"object of incomplete type %qT", type);
+		    break;
+		  case ICV_SECOND_OF_COND:
+		    warning (0, "indirection will not access object of "
+				"incomplete type %qT in second operand "
+				"of conditional expression", type);
+		    break;
+		  case ICV_THIRD_OF_COND:
+		    warning (0, "indirection will not access object of "
+				"incomplete type %qT in third operand "
+				"of conditional expression", type);
+		    break;
+		  case ICV_RIGHT_OF_COMMA:
+		    warning (0, "indirection will not access object of "
+				"incomplete type %qT in right operand of "
+				"comma operator", type);
+		    break;
+		  case ICV_LEFT_OF_COMMA:
+		    warning (0, "indirection will not access object of "
+				"incomplete type %qT in left operand of "
+				"comma operator", type);
+		    break;
+		  case ICV_STATEMENT:
+		    warning (0, "indirection will not access object of "
+				"incomplete type %qT in statement", type);
+		     break;
+		  case ICV_THIRD_IN_FOR:
+		    warning (0, "indirection will not access object of "
+				"incomplete type %qT in for increment "
+				"expression", type);
+		    break;
+		  default:
+		    gcc_unreachable ();
+		}
           }
 	/* Don't load the value if this is an implicit dereference, or if
 	   the type needs to be handled by ctors/dtors.  */
-	else if (is_volatile && (is_reference || TREE_ADDRESSABLE (type)))
+	else if (is_volatile && is_reference)
           {
             if (complain & tf_warning)
-              warning (0, "object of type %qT will not be accessed in %s",
-                       TREE_TYPE (TREE_OPERAND (expr, 0)),
-                       implicit ? implicit : "void context");
+	      switch (implicit)
+		{
+	      	  case ICV_CAST:
+		    warning (0, "conversion to void will not access "
+				"object of type %qT", type);
+		    break;
+		  case ICV_SECOND_OF_COND:
+		    warning (0, "implicit dereference will not access object "
+				"of type %qT in second operand of "
+				"conditional expression", type);
+		    break;
+		  case ICV_THIRD_OF_COND:
+		    warning (0, "implicit dereference will not access object "
+		  	      	"of type %qT in third operand of "
+				"conditional expression", type);
+		    break;
+		  case ICV_RIGHT_OF_COMMA:
+		    warning (0, "implicit dereference will not access object "
+		    		"of type %qT in right operand of "
+				"comma operator", type);
+		    break;
+		  case ICV_LEFT_OF_COMMA:
+		    warning (0, "implicit dereference will not access object "
+		    		"of type %qT in left operand of comma operator",
+			     type);
+		    break;
+		  case ICV_STATEMENT:
+		    warning (0, "implicit dereference will not access object "
+		     		"of type %qT in statement",  type);
+		     break;
+		  case ICV_THIRD_IN_FOR:
+		    warning (0, "implicit dereference will not access object "
+		    		"of type %qT in for increment expression",
+			     type);
+		    break;
+		  default:
+		    gcc_unreachable ();
+		}
           }
+	else if (is_volatile && TREE_ADDRESSABLE (type))
+	  {
+	    if (complain & tf_warning)
+	      switch (implicit)
+		{
+	      	  case ICV_CAST:
+		    warning (0, "conversion to void will not access "
+				"object of non-trivially-copyable type %qT",
+			     type);
+		    break;
+		  case ICV_SECOND_OF_COND:
+		    warning (0, "indirection will not access object of "
+				"non-trivially-copyable type %qT in second "
+				"operand of conditional expression", type);
+		    break;
+		  case ICV_THIRD_OF_COND:
+		    warning (0, "indirection will not access object of "
+		  	      	"non-trivially-copyable type %qT in third "
+				"operand of conditional expression", type);
+		    break;
+		  case ICV_RIGHT_OF_COMMA:
+		    warning (0, "indirection will not access object of "
+		    		"non-trivially-copyable type %qT in right "
+				"operand of comma operator", type);
+		    break;
+		  case ICV_LEFT_OF_COMMA:
+		    warning (0, "indirection will not access object of "
+		    		"non-trivially-copyable type %qT in left "
+				"operand of comma operator", type);
+		    break;
+		  case ICV_STATEMENT:
+		    warning (0, "indirection will not access object of "
+		     		"non-trivially-copyable type %qT in statement",
+			      type);
+		     break;
+		  case ICV_THIRD_IN_FOR:
+		    warning (0, "indirection will not access object of "
+		    		"non-trivially-copyable type %qT in for "
+				"increment expression", type);
+		    break;
+		  default:
+		    gcc_unreachable ();
+		}
+	  }
 	if (is_reference || !is_volatile || !is_complete || TREE_ADDRESSABLE (type))
           {
             /* Emit a warning (if enabled) when the "effect-less" INDIRECT_REF
@@ -936,7 +1057,7 @@ convert_to_void (tree expr, const char *
                - automatic dereferencing of references, since the user cannot
                  control it. (See also warn_if_unused_value() in stmt.c.)  */
             if (warn_unused_value
-		&& implicit
+		&& implicit != ICV_CAST
                 && (complain & tf_warning)
                 && !TREE_NO_WARNING (expr)
                 && !is_reference)
@@ -954,8 +1075,45 @@ convert_to_void (tree expr, const char *
 	int is_complete = COMPLETE_TYPE_P (complete_type (type));
 
 	if (TYPE_VOLATILE (type) && !is_complete && (complain & tf_warning))
-	  warning (0, "object %qE of incomplete type %qT will not be accessed in %s",
-		   expr, type, implicit ? implicit : "void context");
+	  switch (implicit)
+	    {
+	      case ICV_CAST:
+		warning (0, "conversion to void will not access "
+			    "object %qE of incomplete type %qT", expr, type);
+		break;
+	      case ICV_SECOND_OF_COND:
+	        warning (0, "variable %qE of incomplete type %qT will not "
+			    "be accessed in second operand of "
+			    "conditional expression", expr, type);
+		break;
+	      case ICV_THIRD_OF_COND:
+	        warning (0, "variable %qE of incomplete type %qT will not "
+			    "be accessed in third operand of "
+			    "conditional expression", expr, type);
+		break;
+	      case ICV_RIGHT_OF_COMMA:
+	        warning (0, "variable %qE of incomplete type %qT will not "
+			    "be accessed in right operand of comma operator",
+			 expr, type);
+		break;
+	      case ICV_LEFT_OF_COMMA:
+	        warning (0, "variable %qE of incomplete type %qT will not "
+			    "be accessed in left operand of comma operator",
+			 expr, type);
+		break;
+	      case ICV_STATEMENT:
+	        warning (0, "variable %qE of incomplete type %qT will not "
+		            "be accessed in statement", expr, type);
+		break;
+	      case ICV_THIRD_IN_FOR:
+	        warning (0, "variable %qE of incomplete type %qT will not "
+			    "be accessed in for increment expression",
+		         expr, type);
+		break;
+	      default:
+	        gcc_unreachable ();
+	    }
+
 	break;
       }
 
@@ -994,18 +1152,81 @@ convert_to_void (tree expr, const char *
 	/* [over.over] enumerates the places where we can take the address
 	   of an overloaded function, and this is not one of them.  */
 	if (complain & tf_error)
-	  error ("%s cannot resolve address of overloaded function",
-		 implicit ? implicit : "void cast");
+	  switch (implicit)
+	    {
+	      case ICV_CAST:
+		error ("conversion to void "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_SECOND_OF_COND:
+		error ("second operand of conditional expression "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_THIRD_OF_COND:
+		error ("third operand of conditional expression "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_RIGHT_OF_COMMA:
+		error ("right operand of comma operator "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_LEFT_OF_COMMA:
+		error ("left operand of comma operator "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_STATEMENT:
+		error ("statement "
+		       "cannot resolve address of overloaded function");
+		break;
+	      case ICV_THIRD_IN_FOR:
+		error ("for increment expression "
+		       "cannot resolve address of overloaded function");
+		break;
+	    }
 	else
 	  return error_mark_node;
 	expr = void_zero_node;
       }
-    else if (implicit && probe == expr && is_overloaded_fn (probe))
+    else if (implicit != ICV_CAST && probe == expr && is_overloaded_fn (probe))
       {
 	/* Only warn when there is no &.  */
 	if (complain & tf_warning)
-	  warning (OPT_Waddress, "%s is a reference, not call, to function %qE",
-		   implicit, expr);
+	  switch (implicit)
+	    {
+	      case ICV_SECOND_OF_COND:
+	        warning (OPT_Waddress,
+			 "second operand of conditional expression "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      case ICV_THIRD_OF_COND:
+	        warning (OPT_Waddress,
+			 "third operand of conditional expression "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      case ICV_RIGHT_OF_COMMA:
+	        warning (OPT_Waddress,
+			 "right operand of comma operator "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      case ICV_LEFT_OF_COMMA:
+	        warning (OPT_Waddress,
+			 "left operand of comma operator "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      case ICV_STATEMENT:
+	        warning (OPT_Waddress,
+			 "statement is a reference, not call, to function %qE",
+			 expr);
+		break;
+	      case ICV_THIRD_IN_FOR:
+	        warning (OPT_Waddress,
+			 "for increment expression "
+			 "is a reference, not call, to function %qE", expr);
+		break;
+	      default:
+	        gcc_unreachable ();
+	    }
+
 	if (TREE_CODE (expr) == COMPONENT_REF)
 	  expr = TREE_OPERAND (expr, 0);
       }
@@ -1013,7 +1234,7 @@ convert_to_void (tree expr, const char *
 
   if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr)))
     {
-      if (implicit
+      if (implicit != ICV_CAST
 	  && warn_unused_value
 	  && !TREE_NO_WARNING (expr)
 	  && !processing_template_decl)
@@ -1022,7 +1243,35 @@ convert_to_void (tree expr, const char *
 	     been explicitly cast to void, so we must do so here.  */
 	  if (!TREE_SIDE_EFFECTS (expr)) {
             if (complain & tf_warning)
-              warning (OPT_Wunused_value, "%s has no effect", implicit);
+	      switch (implicit)
+		{
+		  case ICV_SECOND_OF_COND:
+		    warning (OPT_Wunused_value,
+			     "second operand of conditional expression has no effect");
+		    break;
+		  case ICV_THIRD_OF_COND:
+		    warning (OPT_Wunused_value,
+		    	     "third operand of conditional expression has no effect");
+		    break;
+		  case ICV_RIGHT_OF_COMMA:
+		    warning (OPT_Wunused_value,
+		    	     "right operand of comma operator has no effect");
+		    break;
+		  case ICV_LEFT_OF_COMMA:
+		    warning (OPT_Wunused_value,
+		    	     "left operand of comma operator has no effect");
+		    break;
+		  case ICV_STATEMENT:
+		    warning (OPT_Wunused_value,
+		    	     "statement has no effect");
+		    break;
+		  case ICV_THIRD_IN_FOR:
+		    warning (OPT_Wunused_value,
+		    	     "for increment expression has no effect");
+		    break;
+		  default:
+		    gcc_unreachable ();
+		}
           }
 	  else
 	    {
Index: cp/cp-tree.h
===================================================================
--- cp/cp-tree.h	(revision 161363)
+++ cp/cp-tree.h	(working copy)
@@ -435,6 +435,17 @@ typedef enum impl_conv_rhs {
   ICR_ASSIGN            /* assignment */
 } impl_conv_rhs;
 
+/* Possible cases of implicit or explicit bad conversions to void. */
+typedef enum impl_conv_void {
+  ICV_CAST,            /* (explicit) conversion to void */
+  ICV_SECOND_OF_COND,  /* second operand of conditional expression */
+  ICV_THIRD_OF_COND,   /* third operand of conditional expression */
+  ICV_RIGHT_OF_COMMA,  /* right operand of comma operator */
+  ICV_LEFT_OF_COMMA,   /* left operand of comma operator */
+  ICV_STATEMENT,       /* statement */
+  ICV_THIRD_IN_FOR     /* for increment expression */
+} impl_conv_void;
+
 /* Macros for access to language-specific slots in an identifier.  */
 
 #define IDENTIFIER_NAMESPACE_BINDINGS(NODE)	\
@@ -4669,8 +4680,8 @@ extern tree ocp_convert				(tree, tree, 
 extern tree cp_convert				(tree, tree);
 extern tree cp_convert_and_check                (tree, tree);
 extern tree cp_fold_convert			(tree, tree);
-extern tree convert_to_void	(tree, const char */*implicit context*/,
-                                 tsubst_flags_t);
+extern tree convert_to_void			(tree, impl_conv_void,
+                                 		 tsubst_flags_t);
 extern tree convert_force			(tree, tree, int);
 extern tree build_expr_type_conversion		(int, tree, bool);
 extern tree type_promotes_to			(tree);
Index: testsuite/g++.dg/warn/noeffect2.C
===================================================================
--- testsuite/g++.dg/warn/noeffect2.C	(revision 161363)
+++ testsuite/g++.dg/warn/noeffect2.C	(working copy)
@@ -10,11 +10,11 @@
 extern "C" void FormatDisk();
   template <class T>
   struct C {
-    C(){ FormatDisk(), 0; }  // { dg-warning "right-hand operand of comma" "" }
+    C(){ FormatDisk(), 0; }  // { dg-warning "right operand of comma" "" }
   };
   template struct C<int>; // { dg-message "instantiated" }
   template <class T>
-  void f() { FormatDisk(), 0; } // { dg-warning "right-hand operand of comma" "" }
+  void f() { FormatDisk(), 0; } // { dg-warning "right operand of comma" "" }
   template void f<int> (); // { dg-message "instantiated" }
-void g() { FormatDisk(), 0; } // { dg-warning "right-hand operand of comma" "" }
+void g() { FormatDisk(), 0; } // { dg-warning "right operand of comma" "" }
 
Index: testsuite/g++.dg/warn/volatile1.C
===================================================================
--- testsuite/g++.dg/warn/volatile1.C	(revision 161363)
+++ testsuite/g++.dg/warn/volatile1.C	(working copy)
@@ -8,5 +8,5 @@ struct A
 };
 void A::baz() volatile
 {
-  *this;			// { dg-warning "will not be accessed" }
+  *this;			// { dg-warning "indirection will not access" }
 }
Index: testsuite/g++.dg/template/warn1.C
===================================================================
--- testsuite/g++.dg/template/warn1.C	(revision 161363)
+++ testsuite/g++.dg/template/warn1.C	(working copy)
@@ -9,8 +9,8 @@
 template <class T>  void Foo(T i) 
 { 
   i++, i++;
-  i, i++; // { dg-warning "left-hand operand" "" }
-  i++, i; // { dg-warning "right-hand operand" "" }
+  i, i++; // { dg-warning "left operand" "" }
+  i++, i; // { dg-warning "right operand" "" }
   for (;; --i, ++i)
     ;
 } 

^ permalink raw reply	[flat|nested] 8+ messages in thread

* Re: [PATCH, c++] Emit the diagnostic messages of convert_to_void
  2010-07-05 10:05         ` Shujing Zhao
@ 2010-07-05 19:59           ` Jason Merrill
  0 siblings, 0 replies; 8+ messages in thread
From: Jason Merrill @ 2010-07-05 19:59 UTC (permalink / raw)
  To: Shujing Zhao
  Cc: GCC Patches, Gabriel Dos Reis, Paolo Carlini,
	Manuel López-Ibáñez

OK.

Jason

^ permalink raw reply	[flat|nested] 8+ messages in thread

end of thread, other threads:[~2010-07-05 19:59 UTC | newest]

Thread overview: 8+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2010-06-17  8:49 [PATCH, c++] Emit the diagnostic messages of convert_to_void Shujing Zhao
2010-06-17  9:38 ` Shujing Zhao
2010-06-17 10:21   ` Shujing Zhao
2010-06-17 10:35     ` Shujing Zhao
2010-07-01  6:28       ` Shujing Zhao
2010-07-02 20:15       ` Jason Merrill
2010-07-05 10:05         ` Shujing Zhao
2010-07-05 19:59           ` Jason Merrill

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).