/cp

2012-05-10  Paolo Carlini  <paolo.carlini@oracle.com>

	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  <paolo.carlini@oracle.com>

	PR c++/53158
	* c-common.c (warnings_for_convert_and_check): Use warning_at.

/testsuite
2012-05-10  Paolo Carlini  <paolo.carlini@oracle.com>

	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 f0e6147e3c5c18e361839a3b33845f04cad1b502..a01f3eaef459000d4931e0e6ec261953b899c062 100644 (file)
--- a/gcc/c-family/ChangeLog
+++ b/gcc/c-family/ChangeLog
@@ -1,3 +1,8 @@
+2012-05-10  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       PR c++/53158
+       * c-common.c (warnings_for_convert_and_check): Use warning_at.
+
 2012-05-10  Richard Guenther  <rguenther@suse.de>
 
        * 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 a5ddbee63c896fa2fe29e478e37eb45667216478..ad988286ee66b6f9a0aef43587064b45c106580c 100644 (file)
--- 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 d749227a47d1b2807661b65da54c4ae94b118f6b..99b1eb5fdf27d97b09108ecbf642d6f9f91cc064 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,15 @@
+2012-05-10  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       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  <paolo.carlini@oracle.com>
 
        PR c++/53301

diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index bf2766fa4604868a477242ea59653e9b55c39edb..53ff78bf9efe34e4ad3ae1888b0fad89909f2240 100644 (file)
--- 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 <conversion>", msg, candidate->fn);
+    inform (loc, "%s%T <conversion>", msg, candidate->fn);
   else if (candidate->viable == -1)
     inform (loc, "%s%#D <near match>", 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 49ba38a3f3961ec0724f4ac6e60861e7183bbd09..3d8f7021d1fa7b3ff81ab6970a5cab55da1c5298 100644 (file)
--- 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 %<void%> to %<bool%>",
+                       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 2b3fcca4188eccd6b6001bb226a1a75b31d4d44e..7eed7548562bfe80f0fe8566ffcbe4a1d75be917 100644 (file)
--- 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 09dac010f732565fd9b28aa92a334cfe4e7d6235..e4e5611683a75c9440e82d4e9309ba0dcbe14273 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,9 @@
+2012-05-10  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       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  <paolo.carlini@oracle.com>
 
        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 (file)
index 0000000..aaa80f4
--- /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 befaf3bb3b86d741168aade9d2b3bc74d5434eef..1084e76d34a89d02e0b788fb4add6721bc96402c 100644 (file)
--- 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()