* [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).