re PR c++/57891 (No diagnostic of narrowing conversion in non-type template argument)

	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.
	* decl.c (compute_array_index_type): Use input_location instead of
	location_of.
	* 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.

From-SVN: r263523

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index e4984bdb17be9d60f25bfdb47020e3b8e2af571e..40b384a1e6202cf48838db47f87b5cf9e53a4014 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,19 @@
+2018-08-13  Marek Polacek  <polacek@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.
+       * decl.c (compute_array_index_type): Use input_location instead of
+       location_of.
+       * 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.
+
 2018-08-13  Martin Sebor  <msebor@redhat.com>
 
        PR tree-optimization/71625

diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index 209c1fd2f0e810b56ad7875471fff21977bcb7be..62654a9e40724232bb9fa015e1b8276b0cd67b75 100644 (file)
--- a/gcc/cp/call.c
+++ b/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 a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 94a85b72d2b3f219dc1c7149124fb118fdae5214..9608cf5334b4cfd5af6349df09bdd15fdf4cad53 100644 (file)
--- a/gcc/cp/cp-tree.h
+++ b/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 a/gcc/cp/decl.c b/gcc/cp/decl.c
index 97f1cfb792e76e7b05c865ee80cbd0b933557678..9a2e3247946667d23d51383ff225318b048e5928 100644 (file)
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -9702,7 +9702,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 a/gcc/cp/pt.c b/gcc/cp/pt.c
index 7fcf5d6b2d3f734de3560071cf06d25bd50b9b9f..cbb7b8ea853de2d4fed8830deb7ad78acadbf3eb 100644 (file)
--- a/gcc/cp/pt.c
+++ b/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 a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c
index 72515d9ece718561f9fca2c4d0410f358b69587f..674d08762b5ae44b952aa5b83fae17474a103c52 100644 (file)
--- a/gcc/cp/typeck2.c
+++ b/gcc/cp/typeck2.c
@@ -875,10 +875,12 @@ store_init_value (tree decl, tree init, vec<tree, va_gc>** cleanups, int flags)
 }
 
 \f
-/* 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 a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index e46072fa9ab486c50e608ab9f36b0d959ee53932..930db3a3514f17b7b373b452df941b05a9597c44 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,26 @@
+2018-08-13  Marek Polacek  <polacek@redhat.com>
+
+       PR c++/57891
+       * 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.
+
 2018-08-13  Segher Boessenkool  <segher@kernel.crashing.org>
 
        * gcc.target/powerpc/pr56605.c: The generated code can have an AND

diff --git a/gcc/testsuite/g++.dg/cpp0x/Wnarrowing10.C b/gcc/testsuite/g++.dg/cpp0x/Wnarrowing10.C
new file mode 100644 (file)
index 0000000..8414b53
--- /dev/null
+++ b/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 a/gcc/testsuite/g++.dg/cpp0x/Wnarrowing6.C b/gcc/testsuite/g++.dg/cpp0x/Wnarrowing6.C
new file mode 100644 (file)
index 0000000..989d277
--- /dev/null
+++ b/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 a/gcc/testsuite/g++.dg/cpp0x/Wnarrowing7.C b/gcc/testsuite/g++.dg/cpp0x/Wnarrowing7.C
new file mode 100644 (file)
index 0000000..099fdfb
--- /dev/null
+++ b/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 a/gcc/testsuite/g++.dg/cpp0x/Wnarrowing8.C b/gcc/testsuite/g++.dg/cpp0x/Wnarrowing8.C
new file mode 100644 (file)
index 0000000..39c924c
--- /dev/null
+++ b/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 a/gcc/testsuite/g++.dg/cpp0x/Wnarrowing9.C b/gcc/testsuite/g++.dg/cpp0x/Wnarrowing9.C
new file mode 100644 (file)
index 0000000..bc8a736
--- /dev/null
+++ b/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 a/gcc/testsuite/g++.dg/cpp0x/constexpr-47969.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-47969.C
index 933831b94de5a567eeca15ea2f2a24aed10a3cd0..201ee17b41b68abe87fe7c50308514d49fd3dbe7 100644 (file)
--- a/gcc/testsuite/g++.dg/cpp0x/constexpr-47969.C
+++ b/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 a/gcc/testsuite/g++.dg/cpp0x/constexpr-data2.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-data2.C
index 898102167de83a35a34c64c3d3ef88fb0fe311bc..dee5ed8230148ce0cbfff21cb000362eba94836a 100644 (file)
--- a/gcc/testsuite/g++.dg/cpp0x/constexpr-data2.C
+++ b/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 a/gcc/testsuite/g++.dg/cpp0x/constexpr-ex2.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-ex2.C
index 34b557ce76eb60efc2d2b9f2a6dfc12402582d2e..ceae9cb75d36e2131afeae8fabe0b5fdf501fa36 100644 (file)
--- a/gcc/testsuite/g++.dg/cpp0x/constexpr-ex2.C
+++ b/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 a/gcc/testsuite/g++.dg/cpp0x/constexpr-targ.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-targ.C
index 98bb502249af49d97f879d5749e27d11110899e0..0f1f113f92fb5257e3e36d322381760e2af944f4 100644 (file)
--- a/gcc/testsuite/g++.dg/cpp0x/constexpr-targ.C
+++ b/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 a/gcc/testsuite/g++.dg/cpp0x/scoped_enum2.C b/gcc/testsuite/g++.dg/cpp0x/scoped_enum2.C
index bb8ad750bd0b6299cf33edbef994d21b57b9e4c7..456b0daedd189f57c600c1e875882fd7c6300305 100644 (file)
--- a/gcc/testsuite/g++.dg/cpp0x/scoped_enum2.C
+++ b/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 a/gcc/testsuite/g++.dg/ext/stmtexpr15.C b/gcc/testsuite/g++.dg/ext/stmtexpr15.C
index 83a831cdd4c68e5a4a003167347c8cb275fa7db6..1a60a0d3cad2bd021a60daf27b8c0b909770c3c6 100644 (file)
--- a/gcc/testsuite/g++.dg/ext/stmtexpr15.C
+++ b/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 a/gcc/testsuite/g++.dg/gomp/pr47963.C b/gcc/testsuite/g++.dg/gomp/pr47963.C
index 5b0c60b80a4ea616ab46c9c814bc2337b8f90cbc..6be4c0e18fb37bb6347061d382ef640b826d2313 100644 (file)
--- a/gcc/testsuite/g++.dg/gomp/pr47963.C
+++ b/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 a/gcc/testsuite/g++.dg/init/new37.C b/gcc/testsuite/g++.dg/init/new37.C
index 9ecbfd7903d2e42b2b4a89a686a0e6f9b02b9aa9..2a42fda33dc5c383e358d0f3bdfee1ebd4b9832c 100644 (file)
--- a/gcc/testsuite/g++.dg/init/new37.C
+++ b/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 a/gcc/testsuite/g++.dg/init/new43.C b/gcc/testsuite/g++.dg/init/new43.C
index 9b0866720fe13658b2458e22e70f5729236a77ee..aa40b42946974ec11ef258354c3c193e4ace226d 100644 (file)
--- a/gcc/testsuite/g++.dg/init/new43.C
+++ b/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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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 a/gcc/testsuite/g++.dg/other/fold1.C b/gcc/testsuite/g++.dg/other/fold1.C
index 23d34546e0b108e2d70a7086b2813717459b62e3..bf074038b04fa245b59b0106d97990a35ab503fc 100644 (file)
--- a/gcc/testsuite/g++.dg/other/fold1.C
+++ b/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 a/gcc/testsuite/g++.dg/other/vrp1.C b/gcc/testsuite/g++.dg/other/vrp1.C
index 0a798c9954ef76fc5ab2842b6980327ff3bac1b6..466a15b4cbb2906d786c410a053772834141d78c 100644 (file)
--- a/gcc/testsuite/g++.dg/other/vrp1.C
+++ b/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 a/gcc/testsuite/g++.dg/parse/array-size2.C b/gcc/testsuite/g++.dg/parse/array-size2.C
index d0bc47fe746618e1e45ffc713d5d8d949b42349d..997b95eed1adcd2de29dc1a0445ea0ed3efd997c 100644 (file)
--- a/gcc/testsuite/g++.dg/parse/array-size2.C
+++ b/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 a/gcc/testsuite/g++.dg/template/char1.C b/gcc/testsuite/g++.dg/template/char1.C
index 51e72e7ad061bc96381eeab45adddc8e1912f18d..a6cffaaf0242464b961e0d08f4cc4604259932c0 100644 (file)
--- a/gcc/testsuite/g++.dg/template/char1.C
+++ b/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 a/gcc/testsuite/g++.dg/template/dependent-name3.C b/gcc/testsuite/g++.dg/template/dependent-name3.C
index bbe6fb66266e8062571845d8f21703b7497fb763..f9d14055a11b3b5fd79596b262dce0c07eb1fc6b 100644 (file)
--- a/gcc/testsuite/g++.dg/template/dependent-name3.C
+++ b/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;