OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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

Browse Source 
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
This commit is contained in:
Marek Polacek 2018-08-13 23:12:11 +00:00 committed by Marek Polacek
parent d66d6d15f1
commit ed4f2c001a
26 changed files with 159 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
gcc/cp/ChangeLog
View File

@ -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

19
gcc/cp/call.c
View File

@ -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);

3
gcc/cp/cp-tree.h
View File

@ -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);

2
gcc/cp/decl.c
View File

@ -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. */

4
gcc/cp/pt.c
View File

@ -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);
}

25
gcc/cp/typeck2.c
View File

@ -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;

23
gcc/testsuite/ChangeLog
View File

@ -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

5
gcc/testsuite/g++.dg/cpp0x/Wnarrowing10.C Normal file
View File

@ -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" }

8
gcc/testsuite/g++.dg/cpp0x/Wnarrowing6.C Normal file
View File

@ -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" }

9
gcc/testsuite/g++.dg/cpp0x/Wnarrowing7.C Normal file
View File

@ -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" }

6
gcc/testsuite/g++.dg/cpp0x/Wnarrowing8.C Normal file
View File

@ -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" }

6
gcc/testsuite/g++.dg/cpp0x/Wnarrowing9.C Normal file
View File

@ -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;

2
gcc/testsuite/g++.dg/cpp0x/constexpr-47969.C
View File

@ -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" }

2
gcc/testsuite/g++.dg/cpp0x/constexpr-data2.C
View File

@ -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" }

2
gcc/testsuite/g++.dg/cpp0x/constexpr-ex2.C
View File

@ -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

2
gcc/testsuite/g++.dg/cpp0x/constexpr-targ.C
View File

@ -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" }

4
gcc/testsuite/g++.dg/cpp0x/scoped_enum2.C
View File

@ -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
};

2
gcc/testsuite/g++.dg/ext/stmtexpr15.C
View File

@ -3,5 +3,5 @@
void foo()
{
int x[({ return; })]; // { dg-error "non-integral" }
int x[({ return; })]; // { dg-error "could not convert|non-integral" }
}

2
gcc/testsuite/g++.dg/gomp/pr47963.C
View File

@ -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)
;
}

2
gcc/testsuite/g++.dg/init/new37.C
View File

@ -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 {

66
gcc/testsuite/g++.dg/init/new43.C
View File

@ -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" }
}

2
gcc/testsuite/g++.dg/other/fold1.C
View File

@ -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" }
};

2
gcc/testsuite/g++.dg/other/vrp1.C
View File

@ -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 } } }

2
gcc/testsuite/g++.dg/parse/array-size2.C
View File

@ -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);
}

3
gcc/testsuite/g++.dg/template/char1.C
View File

@ -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 }

2
gcc/testsuite/g++.dg/template/dependent-name3.C
View File

@ -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;