On Mon, Aug 06, 2018 at 12:02:31AM +1000, Jason Merrill wrote: > > 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. > > Looks good. > > >> >> @@ -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. > > Yes, that's normal. The problem is in build_converted_constant_expr: > > if (conv) > expr = convert_like (conv, expr, complain); > else > expr = error_mark_node; > > Here when setting expr to error_mark_node I forgot to give an error if > (complain & tf_error).
Done. A few testcases needed adjusting but nothing surprising. > >> >> + /* 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.) > > Why later? So this was this wrong error: https://gcc.gnu.org/ml/gcc-patches/2018-07/msg00159.html which was confusing. But I noticed it's because we instantiate 'size' twice: in compute_array_index_type: size = instantiate_non_dependent_expr_sfinae (size, complain); size = build_converted_constant_expr (size_type_node, size, complain); size = maybe_constant_value (size); and then in check_narrowing: init = fold_non_dependent_expr (init, complain); (in this case, size is a call to constexpr user-defined conversion). But check_narrowing now returns early if instantiation_dependent_expression_p, so I thought perhaps we could simply call maybe_constant_value which fixes this problem and doesn't regress anything. Does that seem like a sensible thing to do? > > --- 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, > > It should work to use location_of (osize) here. I dropped this hunk altogether. Because location_of will use DECL_SOURCE_LOCATION for DECLs, the error message will point to the declaration itself, not the use. I don't really care either way. Bootstrapped/regtested on x86_64-linux, ok for trunk? 2018-08-09 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. Give error if expr is error node. (convert_like_real): Pass it to check_narrowing. * cp-tree.h (check_narrowing): Add a default parameter. * pt.c (convert_nontype_argument): Return NULL_TREE if tf_error. * typeck2.c (check_narrowing): Don't warn for instantiation-dependent expressions. Call maybe_constant_value instead of fold_non_dependent_expr. 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-47969.C: Adjust dg-error. * g++.dg/cpp0x/constexpr-ex2.C: Likewise. * g++.dg/cpp0x/constexpr-targ.C: Likewise. * g++.dg/cpp0x/scoped_enum2.C: Likewise. * g++.dg/ext/stmtexpr15.C: Likewise. * g++.dg/gomp/pr47963.C: Likewise. * g++.dg/init/new37.C: Likewise. * g++.dg/init/new43.C: Likewise. * g++.dg/other/fold1.C: Likewise. * g++.dg/parse/array-size2.C: Likewise. * g++.dg/template/dependent-name3.C: Likewise. * g++.dg/cpp0x/constexpr-data2.C: Add dg-error. * g++.dg/other/vrp1.C: Likewise. * g++.dg/template/char1.C: Likewise. diff --git gcc/cp/call.c gcc/cp/call.c index 209c1fd2f0e..62654a9e407 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,9 +4155,18 @@ 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; + { + if (complain & tf_error) + error_at (loc, "could not convert %qE from %qH to %qI", expr, + TREE_TYPE (expr), type); + expr = error_mark_node; + } /* Free all the conversions we allocated. */ obstack_free (&conversion_obstack, p); @@ -7142,7 +7154,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 94a85b72d2b..9608cf5334b 100644 --- gcc/cp/cp-tree.h +++ gcc/cp/cp-tree.h @@ -7397,7 +7397,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/pt.c gcc/cp/pt.c index 7fcf5d6b2d3..cbb7b8ea853 100644 --- gcc/cp/pt.c +++ gcc/cp/pt.c @@ -6682,7 +6682,9 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain) template-parameter. */ 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 (complain & tf_error) ? 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 7763d53ee65..0b886df12f7 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,9 @@ 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)) return ok; if (BRACE_ENCLOSED_INITIALIZER_P (init) @@ -902,7 +906,11 @@ check_narrowing (tree type, tree init, tsubst_flags_t complain) return ok; } - init = fold_non_dependent_expr (init, complain); + init = maybe_constant_value (init); + + /* 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) @@ -967,7 +975,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 +985,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 +998,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/Wnarrowing10.C gcc/testsuite/g++.dg/cpp0x/Wnarrowing10.C index e69de29bb2d..8414b53e342 100644 --- gcc/testsuite/g++.dg/cpp0x/Wnarrowing10.C +++ gcc/testsuite/g++.dg/cpp0x/Wnarrowing10.C @@ -0,0 +1,5 @@ +// PR c++/57891 +// { dg-do compile { target c++11 } } + +template<int N, unsigned char M = N> struct S { char a[N]; }; +S<1000> s; // { dg-error "narrowing conversion" } diff --git gcc/testsuite/g++.dg/cpp0x/Wnarrowing6.C gcc/testsuite/g++.dg/cpp0x/Wnarrowing6.C index e69de29bb2d..989d277cd00 100644 --- gcc/testsuite/g++.dg/cpp0x/Wnarrowing6.C +++ gcc/testsuite/g++.dg/cpp0x/Wnarrowing6.C @@ -0,0 +1,8 @@ +// PR c++/57891 +// { dg-do compile { target c++11 } } + +template<unsigned int> struct A {}; +A<-1> a; // { dg-error "narrowing conversion" } + +template<signed char> struct B {}; +B<1000> b; // { dg-error "narrowing conversion" } diff --git gcc/testsuite/g++.dg/cpp0x/Wnarrowing7.C gcc/testsuite/g++.dg/cpp0x/Wnarrowing7.C index e69de29bb2d..099fdfb7d81 100644 --- gcc/testsuite/g++.dg/cpp0x/Wnarrowing7.C +++ gcc/testsuite/g++.dg/cpp0x/Wnarrowing7.C @@ -0,0 +1,9 @@ +// PR c++/57891 +// { dg-do compile { target c++11 } } +// { dg-options "-Wno-narrowing" } + +template<unsigned int> struct A {}; +A<-1> a; + +template<signed char> struct B {}; +B<1000> b; // { dg-warning "overflow" } diff --git gcc/testsuite/g++.dg/cpp0x/Wnarrowing8.C gcc/testsuite/g++.dg/cpp0x/Wnarrowing8.C index e69de29bb2d..39c924c9c6c 100644 --- gcc/testsuite/g++.dg/cpp0x/Wnarrowing8.C +++ gcc/testsuite/g++.dg/cpp0x/Wnarrowing8.C @@ -0,0 +1,6 @@ +// PR c++/57891 +// { dg-do compile { target c++11 } } + +struct X { constexpr operator int () { return 1000; } }; +template<signed char> struct C {}; +C<X{}> c; // { dg-error "narrowing conversion" } diff --git gcc/testsuite/g++.dg/cpp0x/Wnarrowing9.C gcc/testsuite/g++.dg/cpp0x/Wnarrowing9.C index e69de29bb2d..bc8a736ecb9 100644 --- gcc/testsuite/g++.dg/cpp0x/Wnarrowing9.C +++ gcc/testsuite/g++.dg/cpp0x/Wnarrowing9.C @@ -0,0 +1,6 @@ +// PR c++/57891 +// { dg-do compile { target c++11 } } + +// N is value-dependent, don't warn. +template<int N> struct S { char a[N]; }; // { dg-bogus "narrowing conversion" } +S<1> s; diff --git gcc/testsuite/g++.dg/cpp0x/constexpr-47969.C gcc/testsuite/g++.dg/cpp0x/constexpr-47969.C index 933831b94de..201ee17b41b 100644 --- gcc/testsuite/g++.dg/cpp0x/constexpr-47969.C +++ gcc/testsuite/g++.dg/cpp0x/constexpr-47969.C @@ -8,4 +8,4 @@ struct A constexpr A a = A(); -int ar[a]; // { dg-error "has non-integral type" } +int ar[a]; // { dg-error "could not convert|has non-integral type" } 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/cpp0x/constexpr-ex2.C gcc/testsuite/g++.dg/cpp0x/constexpr-ex2.C index 34b557ce76e..ceae9cb75d3 100644 --- gcc/testsuite/g++.dg/cpp0x/constexpr-ex2.C +++ gcc/testsuite/g++.dg/cpp0x/constexpr-ex2.C @@ -18,5 +18,5 @@ constexpr A a = 42; X<a> x; // OK: unique conversion to int int ar[X<a>::i]; // also OK -int ary[a]; // { dg-error "ambiguous|conversion|array" } ambiguous conversion +int ary[a]; // { dg-error "could not convert|ambiguous|conversion|array" } ambiguous conversion diff --git gcc/testsuite/g++.dg/cpp0x/constexpr-targ.C gcc/testsuite/g++.dg/cpp0x/constexpr-targ.C index 98bb502249a..0f1f113f92f 100644 --- gcc/testsuite/g++.dg/cpp0x/constexpr-targ.C +++ gcc/testsuite/g++.dg/cpp0x/constexpr-targ.C @@ -10,4 +10,4 @@ struct B { }; constexpr A a { }; -B<a> b; // { dg-error "template argument|converted constant" } +B<a> b; // { dg-error "template argument|converted constant|could not convert" } diff --git gcc/testsuite/g++.dg/cpp0x/scoped_enum2.C gcc/testsuite/g++.dg/cpp0x/scoped_enum2.C index bb8ad750bd0..456b0daedd1 100644 --- gcc/testsuite/g++.dg/cpp0x/scoped_enum2.C +++ gcc/testsuite/g++.dg/cpp0x/scoped_enum2.C @@ -4,8 +4,8 @@ enum class E { e = 10 }; enum E2 { e2 = 10 }; struct C { - int arr[E::e]; // { dg-error "non-integral type" } + int arr[E::e]; // { dg-error "could not convert|non-integral type" } int arr2[E2::e2]; // OK - int i: E::e; // { dg-error "non-integral type" } + int i: E::e; // { dg-error "could not convert|non-integral type" } int i2: E2::e2; // OK }; diff --git gcc/testsuite/g++.dg/ext/stmtexpr15.C gcc/testsuite/g++.dg/ext/stmtexpr15.C index 83a831cdd4c..1a60a0d3cad 100644 --- gcc/testsuite/g++.dg/ext/stmtexpr15.C +++ gcc/testsuite/g++.dg/ext/stmtexpr15.C @@ -3,5 +3,5 @@ void foo() { - int x[({ return; })]; // { dg-error "non-integral" } + int x[({ return; })]; // { dg-error "could not convert|non-integral" } } diff --git gcc/testsuite/g++.dg/gomp/pr47963.C gcc/testsuite/g++.dg/gomp/pr47963.C index 5b0c60b80a4..6be4c0e18fb 100644 --- gcc/testsuite/g++.dg/gomp/pr47963.C +++ gcc/testsuite/g++.dg/gomp/pr47963.C @@ -5,7 +5,7 @@ void foo (float n) { - int A[n][n]; // { dg-error "has non-integral type|converted constant expression" } + int A[n][n]; // { dg-error "could not convert|has non-integral type|converted constant expression" } #pragma omp parallel private(A) ; } diff --git gcc/testsuite/g++.dg/init/new37.C gcc/testsuite/g++.dg/init/new37.C index 9ecbfd7903d..2a42fda33dc 100644 --- gcc/testsuite/g++.dg/init/new37.C +++ gcc/testsuite/g++.dg/init/new37.C @@ -32,7 +32,7 @@ template <typename T> void * callnew_fail_3() { - return new T[2][T::n]; // { dg-error "size of array has non-integral type|converted constant expression" } + return new T[2][T::n]; // { dg-error "could not convert|size of array has non-integral type|converted constant expression" } } struct T1 { diff --git gcc/testsuite/g++.dg/init/new43.C gcc/testsuite/g++.dg/init/new43.C index 9b0866720fe..cbb6f2d9da8 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 () @@ -71,43 +71,43 @@ void test_constant_expression () static const signed char i1 = -1; static const signed short i2 = -2; - static const signed int i3 = -3; + static const signed int i3 = -3; // { dg-error "size of array" "" { target c++11 } } static const signed long i4 = -4; static const signed long long i5 = -5; static const int i6 = -6; - static const int i7 = -7; + static const int i7 = -7; // { dg-error "size of array" "" { target c++11 } } // 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 negative|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 negative|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 negative|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 negative|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 negative|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 negative|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 negative|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 negative|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 negative|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 negative|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|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|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|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|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|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|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|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|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|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|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|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..da62b187115 100644 --- gcc/testsuite/g++.dg/template/dependent-name3.C +++ gcc/testsuite/g++.dg/template/dependent-name3.C @@ -5,13 +5,13 @@ template<int I> struct A { static const int zero = 0; - static const int minus_one = -1; + static const int minus_one = -1; // { dg-error "size of array" "" { target c++11} } }; 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;