Ping.
On Mon, Jul 23, 2018 at 04:49:12PM -0400, Marek Polacek wrote:
> On Tue, Jul 03, 2018 at 04:27:33PM -0400, Jason Merrill wrote:
> > On Tue, Jul 3, 2018 at 3:41 PM, Jason Merrill <ja...@redhat.com> wrote:
> > > On Tue, Jul 3, 2018 at 2:58 PM, Marek Polacek <pola...@redhat.com> wrote:
> > >> On Tue, Jul 03, 2018 at 12:40:51PM -0400, Jason Merrill wrote:
> > >>> On Fri, Jun 29, 2018 at 3:58 PM, Marek Polacek <pola...@redhat.com>
> > >>> wrote:
> > >>> > On Wed, Jun 27, 2018 at 07:35:15PM -0400, Jason Merrill wrote:
> > >>> >> On Wed, Jun 27, 2018 at 12:53 PM, Marek Polacek <pola...@redhat.com>
> > >>> >> wrote:
> > >>> >> > This PR complains about us accepting invalid code like
> > >>> >> >
> > >>> >> > template<unsigned int> struct A {};
> > >>> >> > A<-1> a;
> > >>> >> >
> > >>> >> > Where we should detect the narrowing: [temp.arg.nontype] says
> > >>> >> > "A template-argument for a non-type template-parameter shall be a
> > >>> >> > converted
> > >>> >> > constant expression ([expr.const]) of the type of the
> > >>> >> > template-parameter."
> > >>> >> > and a converted constant expression can contain only
> > >>> >> > - integral conversions other than narrowing conversions,
> > >>> >> > - [...]."
> > >>> >> > It spurred e.g.
> > >>> >> > <https://stackoverflow.com/questions/28184888/how-implicit-conversion-works-for-non-type-template-parameters>
> > >>> >> > and has >=3 dups so it has some visibility.
> > >>> >> >
> > >>> >> > I think build_converted_constant_expr needs to set check_narrowing.
> > >>> >> > check_narrowing also always mentions that it's in { } but that is
> > >>> >> > no longer
> > >>> >> > true; in the future it will also apply to <=>. We'd probably have
> > >>> >> > to add a new
> > >>> >> > flag to struct conversion if wanted to distinguish between these.
> > >>> >> >
> > >>> >> > This does not yet fix detecting narrowing in function templates
> > >>> >> > (78244).
> > >>> >> >
> > >>> >> > Bootstrapped/regtested on x86_64-linux, ok for trunk?
> > >>> >> >
> > >>> >> > 2018-06-27 Marek Polacek <pola...@redhat.com>
> > >>> >> >
> > >>> >> > PR c++/57891
> > >>> >> > * call.c (build_converted_constant_expr): Set
> > >>> >> > check_narrowing.
> > >>> >> > * decl.c (compute_array_index_type): Add warning sentinel.
> > >>> >> > Use
> > >>> >> > input_location.
> > >>> >> > * pt.c (convert_nontype_argument): Return NULL_TREE if any
> > >>> >> > errors
> > >>> >> > were reported.
> > >>> >> > * typeck2.c (check_narrowing): Don't mention { } in
> > >>> >> > diagnostic.
> > >>> >> >
> > >>> >> > * g++.dg/cpp0x/Wnarrowing6.C: New test.
> > >>> >> > * g++.dg/cpp0x/Wnarrowing7.C: New test.
> > >>> >> > * g++.dg/cpp0x/Wnarrowing8.C: New test.
> > >>> >> > * g++.dg/cpp0x/constexpr-data2.C: Add dg-error.
> > >>> >> > * g++.dg/init/new43.C: Adjust dg-error.
> > >>> >> > * g++.dg/other/fold1.C: Likewise.
> > >>> >> > * g++.dg/parse/array-size2.C: Likewise.
> > >>> >> > * g++.dg/other/vrp1.C: Add dg-error.
> > >>> >> > * g++.dg/template/char1.C: Likewise.
> > >>> >> > * g++.dg/ext/builtin12.C: Likewise.
> > >>> >> > * g++.dg/template/dependent-name3.C: Adjust dg-error.
> > >>> >> >
> > >>> >> > diff --git gcc/cp/call.c gcc/cp/call.c
> > >>> >> > index 209c1fd2f0e..956c7b149dc 100644
> > >>> >> > --- gcc/cp/call.c
> > >>> >> > +++ gcc/cp/call.c
> > >>> >> > @@ -4152,7 +4152,10 @@ build_converted_constant_expr (tree type,
> > >>> >> > tree expr, tsubst_flags_t complain)
> > >>> >> > }
> > >>> >> >
> > >>> >> > if (conv)
> > >>> >> > - expr = convert_like (conv, expr, complain);
> > >>> >> > + {
> > >>> >> > + conv->check_narrowing = !processing_template_decl;
> > >>> >>
> > >>> >> Why !processing_template_decl? This needs a comment.
> > >>> >
> > >>> > Otherwise we'd warn for e.g.
> > >>> >
> > >>> > template<int N> struct S { char a[N]; };
> > >>> > S<1> s;
> > >>> >
> > >>> > where compute_array_index_type will try to convert the size of the
> > >>> > array (which
> > >>> > is a template_parm_index of type int when parsing the template) to
> > >>> > size_type.
> > >>> > So I guess I can say that we need to wait for instantiation?
> > >>>
> > >>> We certainly shouldn't give a narrowing diagnostic about a
> > >>> value-dependent expression. It probably makes sense to check that at
> > >>> the top of check_narrowing, with all the other early exit conditions.
> > >>> But if we do know the constant value in the template, it's good to
> > >>> complain then rather than wait for instantiation.
> > >>
> > >> Makes sense; how about this then? (Regtest/bootstrap running.)
> > >>
> > >> 2018-07-03 Marek Polacek <pola...@redhat.com>
> > >>
> > >> PR c++/57891
> > >> * call.c (build_converted_constant_expr): Set check_narrowing.
> > >> * decl.c (compute_array_index_type): Add warning sentinel. Use
> > >> input_location.
> > >> * pt.c (convert_nontype_argument): Return NULL_TREE if any errors
> > >> were reported.
> > >> * typeck2.c (check_narrowing): Don't warn for
> > >> instantiation-dependent
> > >> expressions or non-constants in a template. Don't mention { } in
> > >> diagnostic.
> > >>
> > >> * g++.dg/cpp0x/Wnarrowing6.C: New test.
> > >> * g++.dg/cpp0x/Wnarrowing7.C: New test.
> > >> * g++.dg/cpp0x/Wnarrowing8.C: New test.
> > >> * g++.dg/cpp0x/Wnarrowing9.C: New test.
> > >> * g++.dg/cpp0x/Wnarrowing10.C: New test.
> > >> * g++.dg/cpp0x/constexpr-data2.C: Add dg-error.
> > >> * g++.dg/init/new43.C: Adjust dg-error.
> > >> * g++.dg/other/fold1.C: Likewise.
> > >> * g++.dg/parse/array-size2.C: Likewise.
> > >> * g++.dg/other/vrp1.C: Add dg-error.
> > >> * g++.dg/template/char1.C: Likewise.
> > >> * g++.dg/ext/builtin12.C: Likewise.
> > >> * g++.dg/template/dependent-name3.C: Adjust dg-error.
> > >>
> > >> diff --git gcc/cp/call.c gcc/cp/call.c
> > >> index 209c1fd2f0e..4fb0fa8774b 100644
> > >> --- gcc/cp/call.c
> > >> +++ gcc/cp/call.c
> > >> @@ -4152,7 +4152,10 @@ build_converted_constant_expr (tree type, tree
> > >> expr, tsubst_flags_t complain)
> > >> }
> > >>
> > >> if (conv)
> > >> - expr = convert_like (conv, expr, complain);
> > >> + {
> > >> + conv->check_narrowing = true;
> > >> + expr = convert_like (conv, expr, complain);
> > >> + }
> > >> else
> > >> expr = error_mark_node;
> > >>
> > >> diff --git gcc/cp/decl.c gcc/cp/decl.c
> > >> index c04b9b7d457..8da63fa2aaa 100644
> > >> --- gcc/cp/decl.c
> > >> +++ gcc/cp/decl.c
> > >> @@ -9508,6 +9508,8 @@ compute_array_index_type (tree name, tree size,
> > >> tsubst_flags_t complain)
> > >> else
> > >> {
> > >> size = instantiate_non_dependent_expr_sfinae (size, complain);
> > >> + /* Don't warn about narrowing for VLAs. */
> > >> + warning_sentinel s (warn_narrowing, !TREE_CONSTANT (osize));
> > >> size = build_converted_constant_expr (size_type_node, size,
> > >> complain);
> > >
> > > Hmm, perhaps the underlying issue is that we only want
> > > build_converted_constant_expr to check for narrowing of constant
> > > values; if the value isn't constant, it isn't any kind of constant
> > > expression. So perhaps the checking needs to happen as part of
> > > constexpr evaluation.
> >
> > On the other hand, check_narrowing itself forces constexpr evaluation,
> > so this could be handled all in the conversion code; we just need to
> > tell check_narrowing to allow non-constant values in that case.
>
> OK -- see the patch below. Now, I'm not crazy about adding another bit
> to struct conversion, but reusing any of the other bits didn't seem
> safe/possible. Maybe it'll come in handy when dealing with this problem
> for function templates.
>
> > >> @@ -6669,9 +6669,12 @@ convert_nontype_argument (tree type, tree expr,
> > >> tsubst_flags_t complain)
> > >> /* C++17: A template-argument for a non-type
> > >> template-parameter shall
> > >> be a converted constant expression (8.20) of the type of the
> > >> template-parameter. */
> > >> + int errs = errorcount;
> > >> expr = build_converted_constant_expr (type, expr, complain);
> > >> if (expr == error_mark_node)
> > >> - return error_mark_node;
> > >> + /* Make sure we return NULL_TREE only if we have really
> > >> issued
> > >> + an error, as described above. */
> > >> + return errorcount > errs ? NULL_TREE : error_mark_node;
> > >
> > > Is this still needed?
> >
> > Earlier you wrote,
> >
> > > Checking complain doesn't work because that doesn't
> > > say if we have really issued an error. If we have not, and we return
> > > NULL_TREE anyway, we hit this assert:
> > > 8517 gcc_assert (!(complain & tf_error) || seen_error ());
> >
> > If (complain & tf_error), we shouldn't see error_mark_node without an
> > error having been issued. Why is build_converted_constant_expr
> > returning error_mark_node without giving an error when (complain &
> > tf_error)?
>
> This can happen on invalid code; e.g. tests nontype13.C and crash87.C.
> What happens there is that we're trying to convert a METHOD_TYPE to bool,
> which doesn't work: in standard_conversion we go into the
> else if (tcode == BOOLEAN_TYPE)
> block, which returns NULL, implicit_conversion also then returns NULL, yet
> no error has been issued.
>
> > >> + /* If we're in a template and we know the constant value, we can
> > >> + warn. Otherwise wait for instantiation. */
> > >> + || (processing_template_decl && !TREE_CONSTANT (init)))
> > >
> > > I don't think we want this condition. If the value is non-constant
> > > but also not dependent, it'll never be constant, so we can go ahead
> > > and complain.
>
> (This to be investigated later.)
>
> Bootstrapped/regtested on x86_64-linux, ok for trunk?
>
> 2018-07-23 Marek Polacek <pola...@redhat.com>
>
> PR c++/57891
> * call.c (struct conversion): Add check_narrowing_const_only.
> (build_converted_constant_expr): Set check_narrowing and
> check_narrowing_const_only.
> (convert_like_real): Pass it to check_narrowing.
> * cp-tree.h (check_narrowing): Add a default parameter.
> * decl.c (compute_array_index_type): Use input_location.
> * pt.c (convert_nontype_argument): Return NULL_TREE if any errors
> were reported.
> * typeck2.c (check_narrowing): Don't warn for instantiation-dependent
> expressions or non-constants in a template. Don't mention { } in
> diagnostic. Only check narrowing for constants if CONST_ONLY.
>
> * g++.dg/cpp0x/Wnarrowing6.C: New test.
> * g++.dg/cpp0x/Wnarrowing7.C: New test.
> * g++.dg/cpp0x/Wnarrowing8.C: New test.
> * g++.dg/cpp0x/Wnarrowing9.C: New test.
> * g++.dg/cpp0x/Wnarrowing10.C: New test.
> * g++.dg/cpp0x/constexpr-data2.C: Add dg-error.
> * g++.dg/init/new43.C: Adjust dg-error.
> * g++.dg/other/fold1.C: Likewise.
> * g++.dg/parse/array-size2.C: Likewise.
> * g++.dg/template/dependent-name3.C: Likewise.
> * g++.dg/other/vrp1.C: Add dg-error.
> * g++.dg/template/char1.C: Likewise.
>
> diff --git gcc/cp/call.c gcc/cp/call.c
> index 209c1fd2f0e..e612be91070 100644
> --- gcc/cp/call.c
> +++ gcc/cp/call.c
> @@ -107,6 +107,9 @@ struct conversion {
> binding a reference directly or decaying to a pointer. */
> BOOL_BITFIELD rvaluedness_matches_p: 1;
> BOOL_BITFIELD check_narrowing: 1;
> + /* Whether check_narrowing should only check TREE_CONSTANTs; used
> + in build_converted_constant_expr. */
> + BOOL_BITFIELD check_narrowing_const_only: 1;
> /* The type of the expression resulting from the conversion. */
> tree type;
> union {
> @@ -4152,7 +4155,11 @@ build_converted_constant_expr (tree type, tree expr,
> tsubst_flags_t complain)
> }
>
> if (conv)
> - expr = convert_like (conv, expr, complain);
> + {
> + conv->check_narrowing = true;
> + conv->check_narrowing_const_only = true;
> + expr = convert_like (conv, expr, complain);
> + }
> else
> expr = error_mark_node;
>
> @@ -7142,7 +7149,8 @@ convert_like_real (conversion *convs, tree expr, tree
> fn, int argnum,
> }
>
> if (convs->check_narrowing
> - && !check_narrowing (totype, expr, complain))
> + && !check_narrowing (totype, expr, complain,
> + convs->check_narrowing_const_only))
> return error_mark_node;
>
> warning_sentinel w (warn_zero_as_null_pointer_constant);
> diff --git gcc/cp/cp-tree.h gcc/cp/cp-tree.h
> index 0fac7e9892f..656ddbb2150 100644
> --- gcc/cp/cp-tree.h
> +++ gcc/cp/cp-tree.h
> @@ -7354,7 +7354,8 @@ extern int abstract_virtuals_error_sfinae
> (abstract_class_use, tree, tsubst_flag
>
> extern tree store_init_value (tree, tree, vec<tree,
> va_gc>**, int);
> extern tree split_nonconstant_init (tree, tree);
> -extern bool check_narrowing (tree, tree, tsubst_flags_t);
> +extern bool check_narrowing (tree, tree, tsubst_flags_t,
> + bool = false);
> extern tree digest_init (tree, tree,
> tsubst_flags_t);
> extern tree digest_init_flags (tree, tree, int,
> tsubst_flags_t);
> extern tree digest_nsdmi_init (tree, tree,
> tsubst_flags_t);
> diff --git gcc/cp/decl.c gcc/cp/decl.c
> index 3c1e2ef3698..265acf8984e 100644
> --- gcc/cp/decl.c
> +++ gcc/cp/decl.c
> @@ -9581,7 +9581,7 @@ compute_array_index_type (tree name, tree size,
> tsubst_flags_t complain)
> {
> tree folded = cp_fully_fold (size);
> if (TREE_CODE (folded) == INTEGER_CST)
> - pedwarn (location_of (size), OPT_Wpedantic,
> + pedwarn (input_location, OPT_Wpedantic,
> "size of array is not an integral constant-expression");
> /* Use the folded result for VLAs, too; it will have resolved
> SIZEOF_EXPR. */
> diff --git gcc/cp/pt.c gcc/cp/pt.c
> index 27805040ddb..1c70ec6b182 100644
> --- gcc/cp/pt.c
> +++ gcc/cp/pt.c
> @@ -6680,9 +6680,12 @@ convert_nontype_argument (tree type, tree expr,
> tsubst_flags_t complain)
> /* C++17: A template-argument for a non-type template-parameter shall
> be a converted constant expression (8.20) of the type of the
> template-parameter. */
> + int errs = errorcount;
> expr = build_converted_constant_expr (type, expr, complain);
> if (expr == error_mark_node)
> - return error_mark_node;
> + /* Make sure we return NULL_TREE only if we have really issued
> + an error, as described above. */
> + return errorcount > errs ? NULL_TREE : error_mark_node;
> expr = maybe_constant_value (expr);
> expr = convert_from_reference (expr);
> }
> diff --git gcc/cp/typeck2.c gcc/cp/typeck2.c
> index 91aa5a62856..ba9c49b307e 100644
> --- gcc/cp/typeck2.c
> +++ gcc/cp/typeck2.c
> @@ -875,10 +875,12 @@ store_init_value (tree decl, tree init, vec<tree,
> va_gc>** cleanups, int flags)
> }
>
>
> -/* Give diagnostic about narrowing conversions within { }. */
> +/* Give diagnostic about narrowing conversions within { }, or as part of
> + a converted constant expression. If CONST_ONLY, only check
> + constants. */
>
> bool
> -check_narrowing (tree type, tree init, tsubst_flags_t complain)
> +check_narrowing (tree type, tree init, tsubst_flags_t complain, bool
> const_only)
> {
> tree ftype = unlowered_expr_type (init);
> bool ok = true;
> @@ -886,7 +888,12 @@ check_narrowing (tree type, tree init, tsubst_flags_t
> complain)
>
> if (((!warn_narrowing || !(complain & tf_warning))
> && cxx_dialect == cxx98)
> - || !ARITHMETIC_TYPE_P (type))
> + || !ARITHMETIC_TYPE_P (type)
> + /* Don't emit bogus warnings with e.g. value-dependent trees. */
> + || instantiation_dependent_expression_p (init)
> + /* If we're in a template and we know the constant value, we can
> + warn. Otherwise wait for instantiation. */
> + || (processing_template_decl && !TREE_CONSTANT (init)))
> return ok;
>
> if (BRACE_ENCLOSED_INITIALIZER_P (init)
> @@ -904,6 +911,10 @@ check_narrowing (tree type, tree init, tsubst_flags_t
> complain)
>
> init = fold_non_dependent_expr (init, complain);
>
> + /* If we were asked to only check constants, return early. */
> + if (const_only && !TREE_CONSTANT (init))
> + return ok;
> +
> if (TREE_CODE (type) == INTEGER_TYPE
> && TREE_CODE (ftype) == REAL_TYPE)
> ok = false;
> @@ -967,7 +978,7 @@ check_narrowing (tree type, tree init, tsubst_flags_t
> complain)
> {
> if (complain & tf_warning)
> warning_at (loc, OPT_Wnarrowing, "narrowing conversion of %qE "
> - "from %qH to %qI inside { } is ill-formed in C++11",
> + "from %qH to %qI is ill-formed in C++11",
> init, ftype, type);
> ok = true;
> }
> @@ -977,8 +988,7 @@ check_narrowing (tree type, tree init, tsubst_flags_t
> complain)
> {
> if ((!almost_ok || pedantic)
> && pedwarn (loc, OPT_Wnarrowing,
> - "narrowing conversion of %qE "
> - "from %qH to %qI inside { }",
> + "narrowing conversion of %qE from %qH to %qI",
> init, ftype, type)
> && almost_ok)
> inform (loc, " the expression has a constant value but is not "
> @@ -991,8 +1001,8 @@ check_narrowing (tree type, tree init, tsubst_flags_t
> complain)
> int savederrorcount = errorcount;
> global_dc->pedantic_errors = 1;
> pedwarn (loc, OPT_Wnarrowing,
> - "narrowing conversion of %qE from %qH to %qI "
> - "inside { }", init, ftype, type);
> + "narrowing conversion of %qE from %qH to %qI ",
> + init, ftype, type);
> if (errorcount == savederrorcount)
> ok = true;
> global_dc->pedantic_errors = flag_pedantic_errors;
> diff --git gcc/testsuite/g++.dg/cpp0x/constexpr-data2.C
> gcc/testsuite/g++.dg/cpp0x/constexpr-data2.C
> index 898102167de..dee5ed82301 100644
> --- gcc/testsuite/g++.dg/cpp0x/constexpr-data2.C
> +++ gcc/testsuite/g++.dg/cpp0x/constexpr-data2.C
> @@ -43,4 +43,4 @@ extern template struct A3<int, 510>;
>
> // Use.
> A3<int, 1111> a31;
> -A3<char, 9999> a32; // { dg-warning "overflow" }
> +A3<char, 9999> a32; // { dg-error "narrowing conversion" }
> diff --git gcc/testsuite/g++.dg/init/new43.C gcc/testsuite/g++.dg/init/new43.C
> index 9b0866720fe..495c2bb01f0 100644
> --- gcc/testsuite/g++.dg/init/new43.C
> +++ gcc/testsuite/g++.dg/init/new43.C
> @@ -31,35 +31,35 @@ void test_literal ()
>
> // Verify integer literal.
> p = new char [-1]; // { dg-error "size of array is negative" }
> - p = new char [2][-3]; // { dg-error "size of array is negative" }
> + p = new char [2][-3]; // { dg-error "size of array is
> negative|narrowing conversion" }
> p = new char [-4][5]; // { dg-error "size of array is negative" }
> - p = new char [-6][-7]; // { dg-error "size of array is negative" }
> + p = new char [-6][-7]; // { dg-error "size of array is
> negative|narrowing conversion" }
>
> p = new (p) char [-1]; // { dg-error "size of array is negative" }
> - p = new (p) char [2][-3]; // { dg-error "size of array is negative" }
> + p = new (p) char [2][-3]; // { dg-error "size of array is
> negative|narrowing conversion" }
> p = new (p) char [-4][5]; // { dg-error "size of array is negative" }
> - p = new (p) char [-6][-7]; // { dg-error "size of array is negative" }
> + p = new (p) char [-6][-7]; // { dg-error "size of array is
> negative|narrowing conversion" }
>
> p = new (p) A [-1]; // { dg-error "size of array is negative" }
> - p = new (p) A [2][-3]; // { dg-error "size of array is negative" }
> + p = new (p) A [2][-3]; // { dg-error "size of array is
> negative|narrowing conversion" }
> p = new (p) A [-4][5]; // { dg-error "size of array is negative" }
> - p = new (p) A [-6][-7]; // { dg-error "size of array is negative" }
> + p = new (p) A [-6][-7]; // { dg-error "size of array is
> negative|narrowing conversion" }
>
> p = new (p) B [-1]; // { dg-error "size of array is negative" }
> - p = new (p) B [2][-3]; // { dg-error "size of array is negative" }
> + p = new (p) B [2][-3]; // { dg-error "size of array is
> negative|narrowing conversion" }
> p = new (p) B [-4][5]; // { dg-error "size of array is negative" }
> - p = new (p) B [-6][-7]; // { dg-error "size of array is negative" }
> + p = new (p) B [-6][-7]; // { dg-error "size of array is
> negative|narrowing conversion" }
>
> p = new (&b) B [-1]; // { dg-error "size of array is negative" }
> - p = new (&b) B [2][-3]; // { dg-error "size of array is negative" }
> + p = new (&b) B [2][-3]; // { dg-error "size of array is
> negative|narrowing conversion" }
> p = new (&b) B [-4][5]; // { dg-error "size of array is negative" }
> - p = new (&b) B [-6][-7]; // { dg-error "size of array is negative" }
> + p = new (&b) B [-6][-7]; // { dg-error "size of array is
> negative|narrowing conversion" }
>
> p = new char [1 - 2]; // { dg-error "size of array is negative" }
> p = new (p) char [2 - 3]; // { dg-error "size of array is negative" }
> p = new A [2 < 1 ? -1 : -2]; // { dg-error "size of array is negative" }
> p = new (p) B [2 - 3 * 2]; // { dg-error "size of array is negative" }
> - p = new (&b) B [1][2 - 3 * 2];// { dg-error "size of array is negative" }
> + p = new (&b) B [1][2 - 3 * 2];// { dg-error "size of array|narrowing
> conversion" }
> }
>
> void test_constant_expression ()
> @@ -79,35 +79,35 @@ void test_constant_expression ()
>
> // Verify constant expression.
> p = new char [i1]; // { dg-error "size of array is negative" }
> - p = new char [2][i3]; // { dg-error "size of array is negative" }
> + p = new char [2][i3]; // { dg-error "size of array is|narrowing
> conversion" }
> p = new char [i4][5]; // { dg-error "size of array is negative" }
> - p = new char [i6][i7]; // { dg-error "size of array is negative" }
> + p = new char [i6][i7]; // { dg-error "size of array is|narrowing
> conversion" }
>
> p = new (p) char [i1]; // { dg-error "size of array is negative" }
> - p = new (p) char [2][i3]; // { dg-error "size of array is negative" }
> + p = new (p) char [2][i3]; // { dg-error "size of array is|narrowing
> conversion" }
> p = new (p) char [i4][5]; // { dg-error "size of array is negative" }
> - p = new (p) char [i6][i7]; // { dg-error "size of array is negative" }
> + p = new (p) char [i6][i7]; // { dg-error "size of array is|narrowing
> conversion" }
>
> p = new (p) A [i1]; // { dg-error "size of array is negative" }
> - p = new (p) A [2][i3]; // { dg-error "size of array is negative" }
> + p = new (p) A [2][i3]; // { dg-error "size of array is|narrowing
> conversion" }
> p = new (p) A [i4][5]; // { dg-error "size of array is negative" }
> - p = new (p) A [i6][i7]; // { dg-error "size of array is negative" }
> + p = new (p) A [i6][i7]; // { dg-error "size of array is|narrowing
> conversion" }
>
> p = new (p) B [i1]; // { dg-error "size of array is negative" }
> - p = new (p) B [2][i3]; // { dg-error "size of array is negative" }
> + p = new (p) B [2][i3]; // { dg-error "size of array is|narrowing
> conversion" }
> p = new (p) B [i4][5]; // { dg-error "size of array is negative" }
> - p = new (p) B [i6][i7]; // { dg-error "size of array is negative" }
> + p = new (p) B [i6][i7]; // { dg-error "size of array is|narrowing
> conversion" }
>
> p = new (&b) B [i1]; // { dg-error "size of array is negative" }
> - p = new (&b) B [2][i3]; // { dg-error "size of array is negative" }
> + p = new (&b) B [2][i3]; // { dg-error "size of array is|narrowing
> conversion" }
> p = new (&b) B [i4][5]; // { dg-error "size of array is negative" }
> - p = new (&b) B [i6][i7]; // { dg-error "size of array is negative" }
> + p = new (&b) B [i6][i7]; // { dg-error "size of array is|narrowing
> conversion" }
>
> p = new short [i1 - 2]; // { dg-error "size of array is negative" }
> p = new (p) bool [i2 - 3]; // { dg-error "size of array is negative" }
> p = new A [2 < 1 ? i1 : i2]; // { dg-error "size of array is negative" }
> p = new (p) B [2 + i3 * 2]; // { dg-error "size of array is negative" }
> - p = new (&b) B [1][i1 - 3 * 2];// { dg-error "size of array is negative"
> }
> + p = new (&b) B [1][i1 - 3 * 2];// { dg-error "size of array|narrowing
> conversion" }
> }
>
> void test_constexpr ()
> @@ -132,33 +132,33 @@ void test_constexpr ()
>
> // Verify constant expression.
> p = new char [s1]; // { dg-error "size of array is negative" }
> - p = new char [2][s3]; // { dg-error "size of array is negative" }
> + p = new char [2][s3]; // { dg-error "size of array is|narrowing
> conversion" }
> p = new char [s4][5]; // { dg-error "size of array is negative" }
> - p = new char [s6][s7]; // { dg-error "size of array is negative" }
> + p = new char [s6][s7]; // { dg-error "size of array is|narrowing
> conversion" }
>
> p = new (p) char [s1]; // { dg-error "size of array is negative" }
> - p = new (p) char [2][s3]; // { dg-error "size of array is negative" }
> + p = new (p) char [2][s3]; // { dg-error "size of array is|narrowing
> conversion" }
> p = new (p) char [s4][5]; // { dg-error "size of array is negative" }
> - p = new (p) char [s6][s7]; // { dg-error "size of array is negative" }
> + p = new (p) char [s6][s7]; // { dg-error "size of array is|narrowing
> conversion" }
>
> p = new (p) A [s1]; // { dg-error "size of array is negative" }
> - p = new (p) A [2][s3]; // { dg-error "size of array is negative" }
> + p = new (p) A [2][s3]; // { dg-error "size of array is|narrowing
> conversion" }
> p = new (p) A [s4][5]; // { dg-error "size of array is negative" }
> - p = new (p) A [s6][s7]; // { dg-error "size of array is negative" }
> + p = new (p) A [s6][s7]; // { dg-error "size of array is|narrowing
> conversion" }
>
> p = new (p) B [s1]; // { dg-error "size of array is negative" }
> - p = new (p) B [2][s3]; // { dg-error "size of array is negative" }
> + p = new (p) B [2][s3]; // { dg-error "size of array is|narrowing
> conversion" }
> p = new (p) B [s4][5]; // { dg-error "size of array is negative" }
> - p = new (p) B [s6][s7]; // { dg-error "size of array is negative" }
> + p = new (p) B [s6][s7]; // { dg-error "size of array is|narrowing
> conversion" }
>
> p = new (&b) B [s1]; // { dg-error "size of array is negative" }
> - p = new (&b) B [2][s3]; // { dg-error "size of array is negative" }
> + p = new (&b) B [2][s3]; // { dg-error "size of array is|narrowing
> conversion" }
> p = new (&b) B [s4][5]; // { dg-error "size of array is negative" }
> - p = new (&b) B [s6][s7]; // { dg-error "size of array is negative" }
> + p = new (&b) B [s6][s7]; // { dg-error "size of array is|narrowing
> conversion" }
>
> p = new int [s1 + s2]; // { dg-error "size of array is
> negative" }
> p = new (p) long [2 * s3]; // { dg-error "size of array is
> negative" }
> p = new A [s2 < s1 ? s1 : s2]; // { dg-error "size of array is
> negative" }
> p = new (p) B [s7 - s2 * 2]; // { dg-error "size of array is
> negative" }
> - p = new (&b) B [9][s4 - s1 * 2]; // { dg-error "size of array is
> negative" }
> + p = new (&b) B [9][s4 - s1 * 2]; // { dg-error "size of array
> is|narrowing conversion" }
> }
> diff --git gcc/testsuite/g++.dg/other/fold1.C
> gcc/testsuite/g++.dg/other/fold1.C
> index 23d34546e0b..bf074038b04 100644
> --- gcc/testsuite/g++.dg/other/fold1.C
> +++ gcc/testsuite/g++.dg/other/fold1.C
> @@ -4,5 +4,5 @@
> struct A
> {
> static const int i = i; // { dg-error "not declared" }
> - int x[i]; // { dg-error "constant-expression" }
> + int x[i]; // { dg-error
> "constant-expression|narrowing conversion" }
> };
> diff --git gcc/testsuite/g++.dg/other/vrp1.C gcc/testsuite/g++.dg/other/vrp1.C
> index 0a798c9954e..466a15b4cbb 100644
> --- gcc/testsuite/g++.dg/other/vrp1.C
> +++ gcc/testsuite/g++.dg/other/vrp1.C
> @@ -9,4 +9,4 @@ long long mod (long long l, long long r)
> return 0LL;
> return l % r;
> }
> -template long long mod<-0x8000000000000000LL> (long long, long long);
> +template long long mod<-0x8000000000000000LL> (long long, long long); // {
> dg-error "template-id" "" { target { c++11 } } }
> diff --git gcc/testsuite/g++.dg/parse/array-size2.C
> gcc/testsuite/g++.dg/parse/array-size2.C
> index d0bc47fe746..997b95eed1a 100644
> --- gcc/testsuite/g++.dg/parse/array-size2.C
> +++ gcc/testsuite/g++.dg/parse/array-size2.C
> @@ -14,7 +14,7 @@ extern void bar (char *, char *);
> void
> foo (void)
> {
> - char g[(char *) &((struct S *) 0)->b - (char *) 0]; // { dg-error
> "constant" }
> + char g[(char *) &((struct S *) 0)->b - (char *) 0]; // { dg-error
> "constant|narrowing conversion" }
> char h[(__SIZE_TYPE__) &((struct S *) 8)->b]; // { dg-error
> "constant" }
> bar (g, h);
> }
> diff --git gcc/testsuite/g++.dg/template/char1.C
> gcc/testsuite/g++.dg/template/char1.C
> index 51e72e7ad06..a6cffaaf024 100644
> --- gcc/testsuite/g++.dg/template/char1.C
> +++ gcc/testsuite/g++.dg/template/char1.C
> @@ -1,4 +1,5 @@
> template <class CharType, CharType line_terminator = 0>
> class String {};
>
> -String<signed char, 255> s; // { dg-warning "overflow" }
> +String<signed char, 255> s; // { dg-error "narrowing conversion" ""
> { target c++11 } }
> +// { dg-warning "overflow" "" { target c++98_only } .-1 }
> diff --git gcc/testsuite/g++.dg/template/dependent-name3.C
> gcc/testsuite/g++.dg/template/dependent-name3.C
> index bbe6fb66266..f9d14055a11 100644
> --- gcc/testsuite/g++.dg/template/dependent-name3.C
> +++ gcc/testsuite/g++.dg/template/dependent-name3.C
> @@ -11,7 +11,7 @@ template<int I> struct A
> template<int N> struct B
> {
> int x[A<N>::zero]; // { dg-error "zero" }
> - int y[A<N>::minus_one]; // { dg-error "negative" }
> + int y[A<N>::minus_one]; // { dg-error "size of array|narrowing
> conversion" }
> };
>
> B<0> b;
>
> Marek
Marek
