From: paolo Date: Thu, 10 May 2012 21:14:09 +0000 (+0000) Subject: /cp X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=61f69bc91bc10ac0de9d449324d219e2431893cf;p=thirdparty%2Fgcc.git /cp 2012-05-10 Paolo Carlini PR c++/53158 * cvt.c (ocp_convert): Error out early for void -> bool conversions. * typeck.c (decay_conversion): Use error_at. * call.c (build_integral_nontype_arg_conv, convert_like_real, convert_arg_to_ellipsis, perform_implicit_conversion_flags, initialize_reference): Likewise. * cvt.c (warn_ref_binding): Add location_t parameter. (cp_convert_to_pointer, convert_to_reference, ocp_convert, convert_to_void, ): Use error_at and warning_at. /c-family 2012-05-10 Paolo Carlini PR c++/53158 * c-common.c (warnings_for_convert_and_check): Use warning_at. /testsuite 2012-05-10 Paolo Carlini PR c++/53158 * g++.dg/cpp0x/lambda/lambda-err2.C: New. * g++.dg/parse/error26.C: Tweak dg-error column number. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@187380 138bc75d-0d04-0410-961f-82ee72b054a4 --- diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog index f0e6147e3c5c..a01f3eaef459 100644 --- a/gcc/c-family/ChangeLog +++ b/gcc/c-family/ChangeLog @@ -1,3 +1,8 @@ +2012-05-10 Paolo Carlini + + PR c++/53158 + * c-common.c (warnings_for_convert_and_check): Use warning_at. + 2012-05-10 Richard Guenther * c-common.c (c_sizeof_or_alignof_type): Remove assert and diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c index a5ddbee63c89..ad988286ee66 100644 --- a/gcc/c-family/c-common.c +++ b/gcc/c-family/c-common.c @@ -2329,6 +2329,8 @@ conversion_warning (tree type, tree expr) void warnings_for_convert_and_check (tree type, tree expr, tree result) { + location_t loc = EXPR_LOC_OR_HERE (expr); + if (TREE_CODE (expr) == INTEGER_CST && (TREE_CODE (type) == INTEGER_TYPE || TREE_CODE (type) == ENUMERAL_TYPE) @@ -2344,8 +2346,8 @@ warnings_for_convert_and_check (tree type, tree expr, tree result) /* This detects cases like converting -129 or 256 to unsigned char. */ if (!int_fits_type_p (expr, c_common_signed_type (type))) - warning (OPT_Woverflow, - "large integer implicitly truncated to unsigned type"); + warning_at (loc, OPT_Woverflow, + "large integer implicitly truncated to unsigned type"); else conversion_warning (type, expr); } @@ -2357,16 +2359,16 @@ warnings_for_convert_and_check (tree type, tree expr, tree result) && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE || TYPE_PRECISION (TREE_TYPE (expr)) != TYPE_PRECISION (type))) - warning (OPT_Woverflow, - "overflow in implicit constant conversion"); + warning_at (loc, OPT_Woverflow, + "overflow in implicit constant conversion"); else conversion_warning (type, expr); } else if ((TREE_CODE (result) == INTEGER_CST || TREE_CODE (result) == FIXED_CST) && TREE_OVERFLOW (result)) - warning (OPT_Woverflow, - "overflow in implicit constant conversion"); + warning_at (loc, OPT_Woverflow, + "overflow in implicit constant conversion"); else conversion_warning (type, expr); } diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index d749227a47d1..99b1eb5fdf27 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,15 @@ +2012-05-10 Paolo Carlini + + PR c++/53158 + * cvt.c (ocp_convert): Error out early for void -> bool conversions. + * typeck.c (decay_conversion): Use error_at. + * call.c (build_integral_nontype_arg_conv, convert_like_real, + convert_arg_to_ellipsis, perform_implicit_conversion_flags, + initialize_reference): Likewise. + * cvt.c (warn_ref_binding): Add location_t parameter. + (cp_convert_to_pointer, convert_to_reference, ocp_convert, + convert_to_void, ): Use error_at and warning_at. + 2012-05-10 Paolo Carlini PR c++/53301 diff --git a/gcc/cp/call.c b/gcc/cp/call.c index bf2766fa4604..53ff78bf9efe 100644 --- a/gcc/cp/call.c +++ b/gcc/cp/call.c @@ -3182,7 +3182,7 @@ print_z_candidate (const char *msgstr, struct z_candidate *candidate) candidate->convs[0]->type); } else if (TYPE_P (candidate->fn)) - inform (input_location, "%s%T ", msg, candidate->fn); + inform (loc, "%s%T ", msg, candidate->fn); else if (candidate->viable == -1) inform (loc, "%s%#D ", msg, candidate->fn); else if (DECL_DELETED_FN (STRIP_TEMPLATE (candidate->fn))) @@ -3692,6 +3692,7 @@ build_integral_nontype_arg_conv (tree type, tree expr, tsubst_flags_t complain) conversion *conv; void *p; tree t; + location_t loc = EXPR_LOC_OR_HERE (expr); if (error_operand_p (expr)) return error_mark_node; @@ -3727,8 +3728,8 @@ build_integral_nontype_arg_conv (tree type, tree expr, tsubst_flags_t complain) break; if (complain & tf_error) - error ("conversion from %qT to %qT not considered for " - "non-type template argument", t, type); + error_at (loc, "conversion from %qT to %qT not considered for " + "non-type template argument", t, type); /* and fall through. */ default: @@ -5648,6 +5649,7 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, tree totype = convs->type; diagnostic_t diag_kind; int flags; + location_t loc = EXPR_LOC_OR_HERE (expr); if (convs->bad_p && !(complain & tf_error)) return error_mark_node; @@ -5668,13 +5670,13 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, && SCALAR_TYPE_P (totype) && CONSTRUCTOR_NELTS (expr) > 0 && BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (expr, 0)->value)) - permerror (input_location, "too many braces around initializer for %qT", totype); + permerror (loc, "too many braces around initializer for %qT", totype); for (; t ; t = next_conversion (t)) { if (t->kind == ck_user && t->cand->reason) { - permerror (input_location, "invalid user-defined conversion " + permerror (loc, "invalid user-defined conversion " "from %qT to %qT", TREE_TYPE (expr), totype); print_z_candidate ("candidate is:", t->cand); expr = convert_like_real (t, expr, fn, argnum, 1, @@ -5704,7 +5706,7 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, break; } - permerror (input_location, "invalid conversion from %qT to %qT", + permerror (loc, "invalid conversion from %qT to %qT", TREE_TYPE (expr), totype); if (fn) permerror (DECL_SOURCE_LOCATION (fn), @@ -5937,8 +5939,8 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, gcc_assert (TYPE_REF_IS_RVALUE (ref_type) && real_lvalue_p (expr)); - error ("cannot bind %qT lvalue to %qT", - TREE_TYPE (expr), totype); + error_at (loc, "cannot bind %qT lvalue to %qT", + TREE_TYPE (expr), totype); if (fn) error (" initializing argument %P of %q+D", argnum, fn); return error_mark_node; @@ -5969,13 +5971,14 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, /* If the reference is volatile or non-const, we cannot create a temporary. */ if (lvalue & clk_bitfield) - error ("cannot bind bitfield %qE to %qT", - expr, ref_type); + error_at (loc, "cannot bind bitfield %qE to %qT", + expr, ref_type); else if (lvalue & clk_packed) - error ("cannot bind packed field %qE to %qT", - expr, ref_type); + error_at (loc, "cannot bind packed field %qE to %qT", + expr, ref_type); else - error ("cannot bind rvalue %qE to %qT", expr, ref_type); + error_at (loc, "cannot bind rvalue %qE to %qT", + expr, ref_type); return error_mark_node; } /* If the source is a packed field, and we must use a copy @@ -5988,8 +5991,8 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, && CLASS_TYPE_P (type) && type_has_nontrivial_copy_init (type)) { - error ("cannot bind packed field %qE to %qT", - expr, ref_type); + error_at (loc, "cannot bind packed field %qE to %qT", + expr, ref_type); return error_mark_node; } if (lvalue & clk_bitfield) @@ -6055,6 +6058,7 @@ tree convert_arg_to_ellipsis (tree arg, tsubst_flags_t complain) { tree arg_type; + location_t loc = EXPR_LOC_OR_HERE (arg); /* [expr.call] @@ -6076,10 +6080,10 @@ convert_arg_to_ellipsis (tree arg, tsubst_flags_t complain) { if ((complain & tf_warning) && warn_double_promotion && !c_inhibit_evaluation_warnings) - warning (OPT_Wdouble_promotion, - "implicit conversion from %qT to %qT when passing " - "argument to function", - arg_type, double_type_node); + warning_at (loc, OPT_Wdouble_promotion, + "implicit conversion from %qT to %qT when passing " + "argument to function", + arg_type, double_type_node); arg = convert_to_real (double_type_node, arg); } else if (NULLPTR_TYPE_P (arg_type)) @@ -6089,8 +6093,8 @@ convert_arg_to_ellipsis (tree arg, tsubst_flags_t complain) if (SCOPED_ENUM_P (arg_type) && !abi_version_at_least (6)) { if (complain & tf_warning) - warning (OPT_Wabi, "scoped enum %qT will not promote to an " - "integral type in a future version of GCC", arg_type); + warning_at (loc, OPT_Wabi, "scoped enum %qT will not promote to an " + "integral type in a future version of GCC", arg_type); arg = cp_convert (ENUM_UNDERLYING_TYPE (arg_type), arg); } arg = perform_integral_promotions (arg); @@ -6126,8 +6130,8 @@ convert_arg_to_ellipsis (tree arg, tsubst_flags_t complain) || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (arg_type))) { if (complain & tf_error) - error ("cannot pass objects of non-trivially-copyable " - "type %q#T through %<...%>", arg_type); + error_at (loc, "cannot pass objects of non-trivially-copyable " + "type %q#T through %<...%>", arg_type); else return error_mark_node; } @@ -8532,6 +8536,7 @@ perform_implicit_conversion_flags (tree type, tree expr, { conversion *conv; void *p; + location_t loc = EXPR_LOC_OR_HERE (expr); if (error_operand_p (expr)) return error_mark_node; @@ -8554,8 +8559,8 @@ perform_implicit_conversion_flags (tree type, tree expr, else if (invalid_nonstatic_memfn_p (expr, complain)) /* We gave an error. */; else - error ("could not convert %qE from %qT to %qT", expr, - TREE_TYPE (expr), type); + error_at (loc, "could not convert %qE from %qT to %qT", expr, + TREE_TYPE (expr), type); } expr = error_mark_node; } @@ -8833,6 +8838,7 @@ initialize_reference (tree type, tree expr, { conversion *conv; void *p; + location_t loc = EXPR_LOC_OR_HERE (expr); if (type == error_mark_node || error_operand_p (expr)) return error_mark_node; @@ -8851,13 +8857,13 @@ initialize_reference (tree type, tree expr, else if (!CP_TYPE_CONST_P (TREE_TYPE (type)) && !TYPE_REF_IS_RVALUE (type) && !real_lvalue_p (expr)) - error ("invalid initialization of non-const reference of " - "type %qT from an rvalue of type %qT", - type, TREE_TYPE (expr)); + error_at (loc, "invalid initialization of non-const reference of " + "type %qT from an rvalue of type %qT", + type, TREE_TYPE (expr)); else - error ("invalid initialization of reference of type " - "%qT from expression of type %qT", type, - TREE_TYPE (expr)); + error_at (loc, "invalid initialization of reference of type " + "%qT from expression of type %qT", type, + TREE_TYPE (expr)); } return error_mark_node; } diff --git a/gcc/cp/cvt.c b/gcc/cp/cvt.c index 49ba38a3f396..3d8f7021d1fa 100644 --- a/gcc/cp/cvt.c +++ b/gcc/cp/cvt.c @@ -42,7 +42,7 @@ static tree cp_convert_to_pointer (tree, tree); static tree convert_to_pointer_force (tree, tree); static tree build_type_conversion (tree, tree); static tree build_up_reference (tree, tree, int, tree); -static void warn_ref_binding (tree, tree, tree); +static void warn_ref_binding (location_t, tree, tree, tree); /* Change of width--truncation and extension of integers or reals-- is represented with NOP_EXPR. Proper functioning of many things @@ -79,6 +79,8 @@ cp_convert_to_pointer (tree type, tree expr) tree intype = TREE_TYPE (expr); enum tree_code form; tree rval; + location_t loc = EXPR_LOC_OR_HERE (expr); + if (intype == error_mark_node) return error_mark_node; @@ -87,8 +89,8 @@ cp_convert_to_pointer (tree type, tree expr) intype = complete_type (intype); if (!COMPLETE_TYPE_P (intype)) { - error ("can%'t convert from incomplete type %qT to %qT", - intype, type); + error_at (loc, "can%'t convert from incomplete type %qT to %qT", + intype, type); return error_mark_node; } @@ -96,8 +98,8 @@ cp_convert_to_pointer (tree type, tree expr) if (rval) { if (rval == error_mark_node) - error ("conversion of %qE from %qT to %qT is ambiguous", - expr, intype, type); + error_at (loc, "conversion of %qE from %qT to %qT is ambiguous", + expr, intype, type); return rval; } } @@ -166,8 +168,8 @@ cp_convert_to_pointer (tree type, tree expr) if (TYPE_PTRMEMFUNC_P (type)) { - error ("cannot convert %qE from type %qT to type %qT", - expr, intype, type); + error_at (loc, "cannot convert %qE from type %qT to type %qT", + expr, intype, type); return error_mark_node; } @@ -192,8 +194,8 @@ cp_convert_to_pointer (tree type, tree expr) tf_warning_or_error); } } - error ("cannot convert %qE from type %qT to type %qT", - expr, intype, type); + error_at (loc, "cannot convert %qE from type %qT to type %qT", + expr, intype, type); return error_mark_node; } @@ -201,8 +203,8 @@ cp_convert_to_pointer (tree type, tree expr) { if (c_inhibit_evaluation_warnings == 0 && !NULLPTR_TYPE_P (TREE_TYPE (expr))) - warning (OPT_Wzero_as_null_pointer_constant, - "zero as null pointer constant"); + warning_at (loc, OPT_Wzero_as_null_pointer_constant, + "zero as null pointer constant"); if (TYPE_PTRMEMFUNC_P (type)) return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0, @@ -221,7 +223,7 @@ cp_convert_to_pointer (tree type, tree expr) } else if (TYPE_PTR_TO_MEMBER_P (type) && INTEGRAL_CODE_P (form)) { - error ("invalid conversion from %qT to %qT", intype, type); + error_at (loc, "invalid conversion from %qT to %qT", intype, type); return error_mark_node; } @@ -242,8 +244,8 @@ cp_convert_to_pointer (tree type, tree expr) if (type_unknown_p (expr)) return instantiate_type (type, expr, tf_warning_or_error); - error ("cannot convert %qE from type %qT to type %qT", - expr, intype, type); + error_at (loc, "cannot convert %qE from type %qT to type %qT", + expr, intype, type); return error_mark_node; } @@ -367,7 +369,7 @@ build_up_reference (tree type, tree arg, int flags, tree decl) non-volatile const type. */ static void -warn_ref_binding (tree reftype, tree intype, tree decl) +warn_ref_binding (location_t loc, tree reftype, tree intype, tree decl) { tree ttl = TREE_TYPE (reftype); @@ -388,7 +390,7 @@ warn_ref_binding (tree reftype, tree intype, tree decl) msg = G_("conversion to non-const reference type %q#T from " "rvalue of type %qT"); - permerror (input_location, msg, reftype, intype); + permerror (loc, msg, reftype, intype); } } @@ -410,6 +412,7 @@ convert_to_reference (tree reftype, tree expr, int convtype, bool can_convert_intype_to_type; tsubst_flags_t complain = ((flags & LOOKUP_COMPLAIN) ? tf_warning_or_error : tf_none); + location_t loc = EXPR_LOC_OR_HERE (expr); if (TREE_CODE (type) == FUNCTION_TYPE && TREE_TYPE (expr) == unknown_type_node) @@ -455,11 +458,11 @@ convert_to_reference (tree reftype, tree expr, int convtype, tree ttr = lvalue_type (expr); if (! real_lvalue_p (expr)) - warn_ref_binding (reftype, intype, decl); + warn_ref_binding (loc, reftype, intype, decl); if (! (convtype & CONV_CONST) && !at_least_as_qualified_p (ttl, ttr)) - permerror (input_location, "conversion from %qT to %qT discards qualifiers", + permerror (loc, "conversion from %qT to %qT discards qualifiers", ttr, reftype); } @@ -477,8 +480,8 @@ convert_to_reference (tree reftype, tree expr, int convtype, if (TREE_CODE (intype) == POINTER_TYPE && (comptypes (TREE_TYPE (intype), type, COMPARE_BASE | COMPARE_DERIVED))) - warning (0, "casting %qT to %qT does not dereference pointer", - intype, reftype); + warning_at (loc, 0, "casting %qT to %qT does not dereference pointer", + intype, reftype); rval = cp_build_addr_expr (expr, tf_warning_or_error); if (rval != error_mark_node) @@ -494,7 +497,7 @@ convert_to_reference (tree reftype, tree expr, int convtype, tf_warning_or_error); if (rval == NULL_TREE || rval == error_mark_node) return rval; - warn_ref_binding (reftype, intype, decl); + warn_ref_binding (loc, reftype, intype, decl); rval = build_up_reference (reftype, rval, flags, decl); } @@ -505,7 +508,7 @@ convert_to_reference (tree reftype, tree expr, int convtype, } if (flags & LOOKUP_COMPLAIN) - error ("cannot convert type %qT to type %qT", intype, reftype); + error_at (loc, "cannot convert type %qT to type %qT", intype, reftype); return error_mark_node; } @@ -633,6 +636,7 @@ ocp_convert (tree type, tree expr, int convtype, int flags) enum tree_code code = TREE_CODE (type); const char *invalid_conv_diag; tree e1; + location_t loc = EXPR_LOC_OR_HERE (expr); if (error_operand_p (e) || type == error_mark_node) return error_mark_node; @@ -711,8 +715,7 @@ ocp_convert (tree type, tree expr, int convtype, int flags) || TREE_CODE (intype) == POINTER_TYPE) { if (flags & LOOKUP_COMPLAIN) - permerror (input_location, "conversion from %q#T to %q#T", intype, type); - + permerror (loc, "conversion from %q#T to %q#T", intype, type); if (!flag_permissive) return error_mark_node; } @@ -726,10 +729,10 @@ ocp_convert (tree type, tree expr, int convtype, int flags) unspecified. */ if (TREE_CODE (expr) == INTEGER_CST && !int_fits_type_p (expr, ENUM_UNDERLYING_TYPE (type))) - warning (OPT_Wconversion, - "the result of the conversion is unspecified because " - "%qE is outside the range of type %qT", - expr, type); + warning_at (loc, OPT_Wconversion, + "the result of the conversion is unspecified because " + "%qE is outside the range of type %qT", + expr, type); } if (MAYBE_CLASS_TYPE_P (intype)) { @@ -738,11 +741,18 @@ ocp_convert (tree type, tree expr, int convtype, int flags) if (rval) return rval; if (flags & LOOKUP_COMPLAIN) - error ("%q#T used where a %qT was expected", intype, type); + error_at (loc, "%q#T used where a %qT was expected", intype, type); return error_mark_node; } if (code == BOOLEAN_TYPE) { + if (TREE_CODE (intype) == VOID_TYPE) + { + error_at (loc, "could not convert %qE from % to %", + expr); + return error_mark_node; + } + /* We can't implicitly convert a scoped enum to bool, so convert to the underlying type first. */ if (SCOPED_ENUM_P (intype) && (convtype & CONV_STATIC)) @@ -769,7 +779,7 @@ ocp_convert (tree type, tree expr, int convtype, int flags) if (ret_val) return ret_val; if (flags & LOOKUP_COMPLAIN) - error ("%q#T used where a %qT was expected", in_vtype, type); + error_at (loc, "%q#T used where a %qT was expected", in_vtype, type); return error_mark_node; } return fold_if_not_in_template (convert_to_vector (type, e)); @@ -784,7 +794,7 @@ ocp_convert (tree type, tree expr, int convtype, int flags) return rval; else if (flags & LOOKUP_COMPLAIN) - error ("%q#T used where a floating point value was expected", + error_at (loc, "%q#T used where a floating point value was expected", TREE_TYPE (e)); } if (code == REAL_TYPE) @@ -845,8 +855,8 @@ ocp_convert (tree type, tree expr, int convtype, int flags) if (invalid_nonstatic_memfn_p (expr, tf_warning_or_error)) /* We displayed the error message. */; else - error ("conversion from %qT to non-scalar type %qT requested", - TREE_TYPE (expr), type); + error_at (loc, "conversion from %qT to non-scalar type %qT requested", + TREE_TYPE (expr), type); } return error_mark_node; } @@ -873,6 +883,8 @@ ocp_convert (tree type, tree expr, int convtype, int flags) tree convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain) { + location_t loc = EXPR_LOC_OR_HERE (expr); + if (expr == error_mark_node || TREE_TYPE (expr) == error_mark_node) return error_mark_node; @@ -903,7 +915,7 @@ convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain) if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR) { if (complain & tf_error) - error ("pseudo-destructor is not called"); + error_at (loc, "pseudo-destructor is not called"); return error_mark_node; } if (VOID_TYPE_P (TREE_TYPE (expr))) @@ -980,35 +992,35 @@ convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain) switch (implicit) { case ICV_CAST: - warning (0, "conversion to void will not access " + warning_at (loc, 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 " + warning_at (loc, 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 " + warning_at (loc, 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 " + warning_at (loc, 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 " + warning_at (loc, 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 " + warning_at (loc, 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 " + warning_at (loc, 0, "indirection will not access object of " "incomplete type %qT in for increment " "expression", type); break; @@ -1024,37 +1036,37 @@ convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain) switch (implicit) { case ICV_CAST: - warning (0, "conversion to void will not access " + warning_at (loc, 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 " + warning_at (loc, 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 " + warning_at (loc, 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 " + warning_at (loc, 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); + warning_at (loc, 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); + warning_at (loc, 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); + warning_at (loc, 0, "implicit dereference will not access " + "object of type %qT in for increment expression", + type); break; default: gcc_unreachable (); @@ -1066,37 +1078,37 @@ convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain) switch (implicit) { case ICV_CAST: - warning (0, "conversion to void will not access " + warning_at (loc, 0, "conversion to void will not access " "object of non-trivially-copyable type %qT", - type); + type); break; case ICV_SECOND_OF_COND: - warning (0, "indirection will not access object of " + warning_at (loc, 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 " + warning_at (loc, 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 " + warning_at (loc, 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 " + warning_at (loc, 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 " + warning_at (loc, 0, "indirection will not access object of " "non-trivially-copyable type %qT in statement", - type); + type); break; case ICV_THIRD_IN_FOR: - warning (0, "indirection will not access object of " + warning_at (loc, 0, "indirection will not access object of " "non-trivially-copyable type %qT in for " "increment expression", type); break; @@ -1117,7 +1129,7 @@ convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain) && (complain & tf_warning) && !TREE_NO_WARNING (expr) && !is_reference) - warning (OPT_Wunused_value, "value computed is not used"); + warning_at (loc, OPT_Wunused_value, "value computed is not used"); expr = TREE_OPERAND (expr, 0); } @@ -1134,37 +1146,37 @@ convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain) switch (implicit) { case ICV_CAST: - warning (0, "conversion to void will not access " + warning_at (loc, 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 " + warning_at (loc, 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 " + warning_at (loc, 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); + warning_at (loc, 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); + warning_at (loc, 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); + warning_at (loc, 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); + warning_at (loc, 0, "variable %qE of incomplete type %qT will " + "not be accessed in for increment expression", + expr, type); break; default: gcc_unreachable (); @@ -1211,32 +1223,32 @@ convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain) switch (implicit) { case ICV_CAST: - error ("conversion to void " - "cannot resolve address of overloaded function"); + error_at (loc, "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"); + error_at (loc, "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"); + error_at (loc, "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"); + error_at (loc, "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"); + error_at (loc, "left operand of comma operator " + "cannot resolve address of overloaded function"); break; case ICV_STATEMENT: - error ("statement " - "cannot resolve address of overloaded function"); + error_at (loc, "statement " + "cannot resolve address of overloaded function"); break; case ICV_THIRD_IN_FOR: - error ("for increment expression " - "cannot resolve address of overloaded function"); + error_at (loc, "for increment expression " + "cannot resolve address of overloaded function"); break; } else @@ -1250,34 +1262,34 @@ convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain) switch (implicit) { case ICV_SECOND_OF_COND: - warning (OPT_Waddress, - "second operand of conditional expression " - "is a reference, not call, to function %qE", expr); + warning_at (loc, 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); + warning_at (loc, 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); + warning_at (loc, 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); + warning_at (loc, 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); + warning_at (loc, 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); + warning_at (loc, OPT_Waddress, + "for increment expression " + "is a reference, not call, to function %qE", expr); break; default: gcc_unreachable (); @@ -1302,28 +1314,30 @@ convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain) switch (implicit) { case ICV_SECOND_OF_COND: - warning (OPT_Wunused_value, - "second operand of conditional expression has no effect"); + warning_at (loc, 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"); + warning_at (loc, 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"); + warning_at (loc, 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"); + warning_at (loc, OPT_Wunused_value, + "left operand of comma operator has no effect"); break; case ICV_STATEMENT: - warning (OPT_Wunused_value, - "statement has no effect"); + warning_at (loc, OPT_Wunused_value, + "statement has no effect"); break; case ICV_THIRD_IN_FOR: - warning (OPT_Wunused_value, - "for increment expression has no effect"); + warning_at (loc, OPT_Wunused_value, + "for increment expression has no effect"); break; default: gcc_unreachable (); @@ -1361,7 +1375,7 @@ convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain) || code == POSTDECREMENT_EXPR || code == POSTINCREMENT_EXPR))) && (complain & tf_warning)) - warning (OPT_Wunused_value, "value computed is not used"); + warning_at (loc, OPT_Wunused_value, "value computed is not used"); } } expr = build1 (CONVERT_EXPR, void_type_node, expr); diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c index 2b3fcca4188e..7eed7548562b 100644 --- a/gcc/cp/typeck.c +++ b/gcc/cp/typeck.c @@ -1822,6 +1822,7 @@ decay_conversion (tree exp, tsubst_flags_t complain) { tree type; enum tree_code code; + location_t loc = EXPR_LOC_OR_HERE (exp); type = TREE_TYPE (exp); if (type == error_mark_node) @@ -1853,7 +1854,7 @@ decay_conversion (tree exp, tsubst_flags_t complain) if (code == VOID_TYPE) { if (complain & tf_error) - error ("void value not ignored as it ought to be"); + error_at (loc, "void value not ignored as it ought to be"); return error_mark_node; } if (invalid_nonstatic_memfn_p (exp, complain)) @@ -1882,7 +1883,7 @@ decay_conversion (tree exp, tsubst_flags_t complain) && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp))) { if (complain & tf_error) - error ("invalid use of non-lvalue array"); + error_at (loc, "invalid use of non-lvalue array"); return error_mark_node; } diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 09dac010f732..e4e5611683a7 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,9 @@ +2012-05-10 Paolo Carlini + + PR c++/53158 + * g++.dg/cpp0x/lambda/lambda-err2.C: New. + * g++.dg/parse/error26.C: Tweak dg-error column number. + 2012-05-10 Paolo Carlini PR c++/53301 diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-err2.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-err2.C new file mode 100644 index 000000000000..aaa80f470006 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-err2.C @@ -0,0 +1,12 @@ +// PR c++/53158 +// { dg-do compile { target c++11 } } + +int main() +{ + auto a = []() { return true; }; + auto b = []() { return a(); }; // { dg-error "'a' is not captured" } + int c, d; + while (b() && c < d) // { dg-error "could not convert" } + { + } +} diff --git a/gcc/testsuite/g++.dg/parse/error26.C b/gcc/testsuite/g++.dg/parse/error26.C index befaf3bb3b86..1084e76d34a8 100644 --- a/gcc/testsuite/g++.dg/parse/error26.C +++ b/gcc/testsuite/g++.dg/parse/error26.C @@ -4,7 +4,7 @@ void foo() { if (({int c[2];})) ; // { dg-error "7:ISO C.. forbids" "7" } - // { dg-error "20:could not convert" "20" { target *-*-* } 6 } + // { dg-error "17:could not convert" "17" { target *-*-* } 6 } } void bar()