user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rollup merge of #69185 - RalfJung:const-prop-lints, r=oli-obk

Browse source 
Unify and improve const-prop lints

Add a single helper method for all lints emitted by const-prop, and make that lint different from the CTFE `const_err` lint. Also consistently check overflow on *arithmetic*, not on the assertion, to make behavior the same for debug and release builds.

See [this summary comment](https://github.com/rust-lang/rust/pull/69185#issuecomment-587924754) for details and the latest status.

In terms of lint formatting, I went for what seems to be the better style: have a general message above the code, and then a specific message at the span:
```
error: this arithmetic operation will overflow
  --> $DIR/const-err2.rs:21:18
   |
LL |     let a_i128 = -std::i128::MIN;
   |                  ^^^^^^^^^^^^^^^ attempt to negate with overflow
```
We could also just have the specific message above and no text at the span if that is preferred.

I also converted some of the existing tests to use compiletest revisions, so that the same test can check a bunch of different compile flags.

Fixes https://github.com/rust-lang/rust/issues/69020.
Helps with https://github.com/rust-lang/rust/issues/69021: debug/release are now consistent, but the assoc-const test in that issue still fails (there is a FIXME in the PR for this). The reason seems to be that const-prop notices the assoc const in `T::N << 42` and does not even bother calling `const_prop` on that operation.
Has no effect on https://github.com/rust-lang/rust/issues/61821; the duplication there has entirely different reasons.
This commit is contained in:
Mazdak Farrokhzad 2020-02-20 20:18:50 +01:00 • committed by GitHub
commit d237e0fc6c
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
71 changed files with 1614 additions and 1110 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/test/ui/consts/array-literal-index-oob.rs
View file

@ -1,11 +1,11 @@
// build-pass
// ignore-pass (emit codegen-time warnings and verify that they are indeed warnings and not errors)
#![warn(const_err)]
#![warn(const_err, unconditional_panic)]
fn main() {
&{ [1, 2, 3][4] };
//~^ WARN index out of bounds
//~^ WARN operation will panic
//~| WARN reaching this expression at runtime will panic or abort
//~| WARN erroneous constant used [const_err]
}

16
src/test/ui/consts/array-literal-index-oob.stderr
View file

@ -1,14 +1,14 @@
warning: index out of bounds: the len is 3 but the index is 4
warning: this operation will panic at runtime
--> $DIR/array-literal-index-oob.rs:7:8
|
LL | &{ [1, 2, 3][4] };
| ^^^^^^^^^^^^
| ^^^^^^^^^^^^ index out of bounds: the len is 3 but the index is 4
|
note: the lint level is defined here
--> $DIR/array-literal-index-oob.rs:4:9
--> $DIR/array-literal-index-oob.rs:4:20
|
LL | #![warn(const_err)]
| ^^^^^^^^^
LL | #![warn(const_err, unconditional_panic)]
| ^^^^^^^^^^^^^^^^^^^
warning: reaching this expression at runtime will panic or abort
--> $DIR/array-literal-index-oob.rs:7:8
@ -17,6 +17,12 @@ LL | &{ [1, 2, 3][4] };
| ---^^^^^^^^^^^^--
| |
| indexing out of bounds: the len is 3 but the index is 4
|
note: the lint level is defined here
--> $DIR/array-literal-index-oob.rs:4:9
|
LL | #![warn(const_err, unconditional_panic)]
| ^^^^^^^^^
warning: erroneous constant used
--> $DIR/array-literal-index-oob.rs:7:5

2
src/test/ui/consts/const-err.rs
View file

@ -1,7 +1,7 @@
// build-fail
// compile-flags: -Zforce-overflow-checks=on
#![allow(exceeding_bitshifts)]
#![allow(arithmetic_overflow)]
#![warn(const_err)]
fn black_box<T>(_: T) {

38
src/test/ui/consts/const-err2.stderr → src/test/ui/consts/const-err2.noopt.stderr
View file

@ -1,50 +1,48 @@
error: this expression will panic at runtime
--> $DIR/const-err2.rs:18:13
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:19:13
|
LL | let a = -std::i8::MIN;
| ^^^^^^^^^^^^^ attempt to negate with overflow
|
note: the lint level is defined here
--> $DIR/const-err2.rs:11:9
|
LL | #![deny(const_err)]
| ^^^^^^^^^
= note: `#[deny(arithmetic_overflow)]` on by default
error: this expression will panic at runtime
--> $DIR/const-err2.rs:20:18
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:21:18
|
LL | let a_i128 = -std::i128::MIN;
| ^^^^^^^^^^^^^^^ attempt to negate with overflow
error: this expression will panic at runtime
--> $DIR/const-err2.rs:22:13
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:23:13
|
LL | let b = 200u8 + 200u8 + 200u8;
| ^^^^^^^^^^^^^ attempt to add with overflow
error: this expression will panic at runtime
--> $DIR/const-err2.rs:24:18
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:25:18
|
LL | let b_i128 = std::i128::MIN - std::i128::MAX;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to subtract with overflow
error: this expression will panic at runtime
--> $DIR/const-err2.rs:26:13
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:27:13
|
LL | let c = 200u8 * 4;
| ^^^^^^^^^ attempt to multiply with overflow
error: this expression will panic at runtime
--> $DIR/const-err2.rs:28:13
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:29:13
|
LL | let d = 42u8 - (42u8 + 1);
| ^^^^^^^^^^^^^^^^^ attempt to subtract with overflow
error: index out of bounds: the len is 1 but the index is 1
--> $DIR/const-err2.rs:30:14
error: this operation will panic at runtime
--> $DIR/const-err2.rs:31:14
|
LL | let _e = [5u8][1];
| ^^^^^^^^
| ^^^^^^^^ index out of bounds: the len is 1 but the index is 1
|
= note: `#[deny(unconditional_panic)]` on by default
error: aborting due to 7 previous errors

48
src/test/ui/consts/const-err2.opt.stderr Normal file
View file

@ -0,0 +1,48 @@
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:19:13
|
LL | let a = -std::i8::MIN;
| ^^^^^^^^^^^^^ attempt to negate with overflow
|
= note: `#[deny(arithmetic_overflow)]` on by default
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:21:18
|
LL | let a_i128 = -std::i128::MIN;
| ^^^^^^^^^^^^^^^ attempt to negate with overflow
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:23:13
|
LL | let b = 200u8 + 200u8 + 200u8;
| ^^^^^^^^^^^^^ attempt to add with overflow
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:25:18
|
LL | let b_i128 = std::i128::MIN - std::i128::MAX;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to subtract with overflow
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:27:13
|
LL | let c = 200u8 * 4;
| ^^^^^^^^^ attempt to multiply with overflow
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:29:13
|
LL | let d = 42u8 - (42u8 + 1);
| ^^^^^^^^^^^^^^^^^ attempt to subtract with overflow
error: this operation will panic at runtime
--> $DIR/const-err2.rs:31:14
|
LL | let _e = [5u8][1];
| ^^^^^^^^ index out of bounds: the len is 1 but the index is 1
|
= note: `#[deny(unconditional_panic)]` on by default
error: aborting due to 7 previous errors

48
src/test/ui/consts/const-err2.opt_with_overflow_checks.stderr Normal file
View file

@ -0,0 +1,48 @@
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:19:13
|
LL | let a = -std::i8::MIN;
| ^^^^^^^^^^^^^ attempt to negate with overflow
|
= note: `#[deny(arithmetic_overflow)]` on by default
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:21:18
|
LL | let a_i128 = -std::i128::MIN;
| ^^^^^^^^^^^^^^^ attempt to negate with overflow
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:23:13
|
LL | let b = 200u8 + 200u8 + 200u8;
| ^^^^^^^^^^^^^ attempt to add with overflow
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:25:18
|
LL | let b_i128 = std::i128::MIN - std::i128::MAX;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to subtract with overflow
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:27:13
|
LL | let c = 200u8 * 4;
| ^^^^^^^^^ attempt to multiply with overflow
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:29:13
|
LL | let d = 42u8 - (42u8 + 1);
| ^^^^^^^^^^^^^^^^^ attempt to subtract with overflow
error: this operation will panic at runtime
--> $DIR/const-err2.rs:31:14
|
LL | let _e = [5u8][1];
| ^^^^^^^^ index out of bounds: the len is 1 but the index is 1
|
= note: `#[deny(unconditional_panic)]` on by default
error: aborting due to 7 previous errors

23
src/test/ui/consts/const-err2.rs
View file

@ -2,13 +2,14 @@
// optimized compilation and unoptimized compilation and thus would
// lead to different lints being emitted
// revisions: noopt opt opt_with_overflow_checks
//[noopt]compile-flags: -C opt-level=0
//[opt]compile-flags: -O
//[opt_with_overflow_checks]compile-flags: -C overflow-checks=on -O
// build-fail
// compile-flags: -O
#![feature(rustc_attrs)]
#![allow(exceeding_bitshifts)]
#![deny(const_err)]
fn black_box<T>(_: T) {
unimplemented!()
@ -16,19 +17,19 @@ fn black_box<T>(_: T) {
fn main() {
let a = -std::i8::MIN;
//~^ ERROR const_err
//~^ ERROR arithmetic operation will overflow
let a_i128 = -std::i128::MIN;
//~^ ERROR const_err
//~^ ERROR arithmetic operation will overflow
let b = 200u8 + 200u8 + 200u8;
//~^ ERROR const_err
//~^ ERROR arithmetic operation will overflow
let b_i128 = std::i128::MIN - std::i128::MAX;
//~^ ERROR const_err
//~^ ERROR arithmetic operation will overflow
let c = 200u8 * 4;
//~^ ERROR const_err
//~^ ERROR arithmetic operation will overflow
let d = 42u8 - (42u8 + 1);
//~^ ERROR const_err
//~^ ERROR arithmetic operation will overflow
let _e = [5u8][1];
//~^ ERROR const_err
//~^ ERROR operation will panic
black_box(a);
black_box(a_i128);
black_box(b);

38
src/test/ui/consts/const-err3.rs
View file

@ -1,38 +0,0 @@
// needed because negating int::MIN will behave differently between
// optimized compilation and unoptimized compilation and thus would
// lead to different lints being emitted
// build-fail
// compile-flags: -C overflow-checks=on -O
#![feature(rustc_attrs)]
#![allow(exceeding_bitshifts)]
#![deny(const_err)]
fn black_box<T>(_: T) {
unimplemented!()
}
fn main() {
let a = -std::i8::MIN;
//~^ ERROR const_err
let a_i128 = -std::i128::MIN;
//~^ ERROR const_err
let b = 200u8 + 200u8 + 200u8;
//~^ ERROR const_err
let b_i128 = std::i128::MIN - std::i128::MAX;
//~^ ERROR const_err
let c = 200u8 * 4;
//~^ ERROR const_err
let d = 42u8 - (42u8 + 1);
//~^ ERROR const_err
let _e = [5u8][1];
//~^ ERROR const_err
black_box(a);
black_box(a_i128);
black_box(b);
black_box(b_i128);
black_box(c);
black_box(d);
}

50
src/test/ui/consts/const-err3.stderr
View file

@ -1,50 +0,0 @@
error: attempt to negate with overflow
--> $DIR/const-err3.rs:18:13
|
LL | let a = -std::i8::MIN;
| ^^^^^^^^^^^^^
|
note: the lint level is defined here
--> $DIR/const-err3.rs:11:9
|
LL | #![deny(const_err)]
| ^^^^^^^^^
error: attempt to negate with overflow
--> $DIR/const-err3.rs:20:18
|
LL | let a_i128 = -std::i128::MIN;
| ^^^^^^^^^^^^^^^
error: attempt to add with overflow
--> $DIR/const-err3.rs:22:13
|
LL | let b = 200u8 + 200u8 + 200u8;
| ^^^^^^^^^^^^^
error: attempt to subtract with overflow
--> $DIR/const-err3.rs:24:18
|
LL | let b_i128 = std::i128::MIN - std::i128::MAX;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: attempt to multiply with overflow
--> $DIR/const-err3.rs:26:13
|
LL | let c = 200u8 * 4;
| ^^^^^^^^^
error: attempt to subtract with overflow
--> $DIR/const-err3.rs:28:13
|
LL | let d = 42u8 - (42u8 + 1);
| ^^^^^^^^^^^^^^^^^
error: index out of bounds: the len is 1 but the index is 1
--> $DIR/const-err3.rs:30:14
|
LL | let _e = [5u8][1];
| ^^^^^^^^
error: aborting due to 7 previous errors

2
src/test/ui/consts/const-eval/index_out_of_bounds_propagated.rs
View file

@ -2,5 +2,5 @@
fn main() {
let array = [std::env::args().len()];
array[1]; //~ ERROR index out of bounds
array[1]; //~ ERROR operation will panic
}

6
src/test/ui/consts/const-eval/index_out_of_bounds_propagated.stderr
View file

@ -1,10 +1,10 @@
error: index out of bounds: the len is 1 but the index is 1
error: this operation will panic at runtime
--> $DIR/index_out_of_bounds_propagated.rs:5:5
|
LL | array[1];
| ^^^^^^^^
| ^^^^^^^^ index out of bounds: the len is 1 but the index is 1
|
= note: `#[deny(const_err)]` on by default
= note: `#[deny(unconditional_panic)]` on by default
error: aborting due to previous error

78
src/test/ui/consts/const-eval/promoted_errors.noopt.stderr Normal file
View file

@ -0,0 +1,78 @@
warning: this arithmetic operation will overflow
--> $DIR/promoted_errors.rs:12:20
|
LL | println!("{}", 0u32 - 1);
| ^^^^^^^^ attempt to subtract with overflow
|
note: the lint level is defined here
--> $DIR/promoted_errors.rs:9:20
|
LL | #![warn(const_err, arithmetic_overflow, unconditional_panic)]
| ^^^^^^^^^^^^^^^^^^^
warning: this arithmetic operation will overflow
--> $DIR/promoted_errors.rs:14:14
|
LL | let _x = 0u32 - 1;
| ^^^^^^^^ attempt to subtract with overflow
warning: this operation will panic at runtime
--> $DIR/promoted_errors.rs:16:20
|
LL | println!("{}", 1 / (1 - 1));
| ^^^^^^^^^^^ attempt to divide by zero
|
note: the lint level is defined here
--> $DIR/promoted_errors.rs:9:41
|
LL | #![warn(const_err, arithmetic_overflow, unconditional_panic)]
| ^^^^^^^^^^^^^^^^^^^
warning: reaching this expression at runtime will panic or abort
--> $DIR/promoted_errors.rs:16:20
|
LL | println!("{}", 1 / (1 - 1));
| ^^^^^^^^^^^ dividing by zero
|
note: the lint level is defined here
--> $DIR/promoted_errors.rs:9:9
|
LL | #![warn(const_err, arithmetic_overflow, unconditional_panic)]
| ^^^^^^^^^
warning: erroneous constant used
--> $DIR/promoted_errors.rs:16:20
|
LL | println!("{}", 1 / (1 - 1));
| ^^^^^^^^^^^ referenced constant has errors
warning: this operation will panic at runtime
--> $DIR/promoted_errors.rs:20:14
|
LL | let _x = 1 / (1 - 1);
| ^^^^^^^^^^^ attempt to divide by zero
warning: this operation will panic at runtime
--> $DIR/promoted_errors.rs:22:20
|
LL | println!("{}", 1 / (false as u32));
| ^^^^^^^^^^^^^^^^^^ attempt to divide by zero
warning: reaching this expression at runtime will panic or abort
--> $DIR/promoted_errors.rs:22:20
|
LL | println!("{}", 1 / (false as u32));
| ^^^^^^^^^^^^^^^^^^ dividing by zero
warning: erroneous constant used
--> $DIR/promoted_errors.rs:22:20
|
LL | println!("{}", 1 / (false as u32));
| ^^^^^^^^^^^^^^^^^^ referenced constant has errors
warning: this operation will panic at runtime
--> $DIR/promoted_errors.rs:26:14
|
LL | let _x = 1 / (false as u32);
| ^^^^^^^^^^^^^^^^^^ attempt to divide by zero

72
src/test/ui/consts/const-eval/promoted_errors.opt.stderr Normal file
View file

@ -0,0 +1,72 @@
warning: this arithmetic operation will overflow
--> $DIR/promoted_errors.rs:14:14
|
LL | let _x = 0u32 - 1;
| ^^^^^^^^ attempt to subtract with overflow
|
note: the lint level is defined here
--> $DIR/promoted_errors.rs:9:20
|
LL | #![warn(const_err, arithmetic_overflow, unconditional_panic)]
| ^^^^^^^^^^^^^^^^^^^
warning: this operation will panic at runtime
--> $DIR/promoted_errors.rs:16:20
|
LL | println!("{}", 1 / (1 - 1));
| ^^^^^^^^^^^ attempt to divide by zero
|
note: the lint level is defined here
--> $DIR/promoted_errors.rs:9:41
|
LL | #![warn(const_err, arithmetic_overflow, unconditional_panic)]
| ^^^^^^^^^^^^^^^^^^^
warning: reaching this expression at runtime will panic or abort
--> $DIR/promoted_errors.rs:16:20
|
LL | println!("{}", 1 / (1 - 1));
| ^^^^^^^^^^^ dividing by zero
|
note: the lint level is defined here
--> $DIR/promoted_errors.rs:9:9
|
LL | #![warn(const_err, arithmetic_overflow, unconditional_panic)]
| ^^^^^^^^^
warning: erroneous constant used
--> $DIR/promoted_errors.rs:16:20
|
LL | println!("{}", 1 / (1 - 1));
| ^^^^^^^^^^^ referenced constant has errors
warning: this operation will panic at runtime
--> $DIR/promoted_errors.rs:20:14
|
LL | let _x = 1 / (1 - 1);
| ^^^^^^^^^^^ attempt to divide by zero
warning: this operation will panic at runtime
--> $DIR/promoted_errors.rs:22:20
|
LL | println!("{}", 1 / (false as u32));
| ^^^^^^^^^^^^^^^^^^ attempt to divide by zero
warning: reaching this expression at runtime will panic or abort
--> $DIR/promoted_errors.rs:22:20
|
LL | println!("{}", 1 / (false as u32));
| ^^^^^^^^^^^^^^^^^^ dividing by zero
warning: erroneous constant used
--> $DIR/promoted_errors.rs:22:20
|
LL | println!("{}", 1 / (false as u32));
| ^^^^^^^^^^^^^^^^^^ referenced constant has errors
warning: this operation will panic at runtime
--> $DIR/promoted_errors.rs:26:14
|
LL | let _x = 1 / (false as u32);
| ^^^^^^^^^^^^^^^^^^ attempt to divide by zero

78
src/test/ui/consts/const-eval/promoted_errors.opt_with_overflow_checks.stderr Normal file
View file

@ -0,0 +1,78 @@
warning: this arithmetic operation will overflow
--> $DIR/promoted_errors.rs:12:20
|
LL | println!("{}", 0u32 - 1);
| ^^^^^^^^ attempt to subtract with overflow
|
note: the lint level is defined here
--> $DIR/promoted_errors.rs:9:20
|
LL | #![warn(const_err, arithmetic_overflow, unconditional_panic)]
| ^^^^^^^^^^^^^^^^^^^
warning: this arithmetic operation will overflow
--> $DIR/promoted_errors.rs:14:14
|
LL | let _x = 0u32 - 1;
| ^^^^^^^^ attempt to subtract with overflow
warning: this operation will panic at runtime
--> $DIR/promoted_errors.rs:16:20
|
LL | println!("{}", 1 / (1 - 1));
| ^^^^^^^^^^^ attempt to divide by zero
|
note: the lint level is defined here
--> $DIR/promoted_errors.rs:9:41
|
LL | #![warn(const_err, arithmetic_overflow, unconditional_panic)]
| ^^^^^^^^^^^^^^^^^^^
warning: reaching this expression at runtime will panic or abort
--> $DIR/promoted_errors.rs:16:20
|
LL | println!("{}", 1 / (1 - 1));
| ^^^^^^^^^^^ dividing by zero
|
note: the lint level is defined here
--> $DIR/promoted_errors.rs:9:9
|
LL | #![warn(const_err, arithmetic_overflow, unconditional_panic)]
| ^^^^^^^^^
warning: erroneous constant used
--> $DIR/promoted_errors.rs:16:20
|
LL | println!("{}", 1 / (1 - 1));
| ^^^^^^^^^^^ referenced constant has errors
warning: this operation will panic at runtime
--> $DIR/promoted_errors.rs:20:14
|
LL | let _x = 1 / (1 - 1);
| ^^^^^^^^^^^ attempt to divide by zero
warning: this operation will panic at runtime
--> $DIR/promoted_errors.rs:22:20
|
LL | println!("{}", 1 / (false as u32));
| ^^^^^^^^^^^^^^^^^^ attempt to divide by zero
warning: reaching this expression at runtime will panic or abort
--> $DIR/promoted_errors.rs:22:20
|
LL | println!("{}", 1 / (false as u32));
| ^^^^^^^^^^^^^^^^^^ dividing by zero
warning: erroneous constant used
--> $DIR/promoted_errors.rs:22:20
|
LL | println!("{}", 1 / (false as u32));
| ^^^^^^^^^^^^^^^^^^ referenced constant has errors
warning: this operation will panic at runtime
--> $DIR/promoted_errors.rs:26:14
|
LL | let _x = 1 / (false as u32);
| ^^^^^^^^^^^^^^^^^^ attempt to divide by zero

23
src/test/ui/consts/const-eval/promoted_errors.rs
View file

@ -1,23 +1,28 @@
// revisions: noopt opt opt_with_overflow_checks
//[noopt]compile-flags: -C opt-level=0
//[opt]compile-flags: -O
//[opt_with_overflow_checks]compile-flags: -C overflow-checks=on -O
// build-pass
// ignore-pass (emit codegen-time warnings and verify that they are indeed warnings and not errors)
// compile-flags: -O
#![warn(const_err)]
#![warn(const_err, arithmetic_overflow, unconditional_panic)]
fn main() {
println!("{}", 0u32 - 1);
//[opt_with_overflow_checks,noopt]~^ WARN [arithmetic_overflow]
let _x = 0u32 - 1;
//~^ WARN const_err
//~^ WARN [arithmetic_overflow]
println!("{}", 1 / (1 - 1));
//~^ WARN attempt to divide by zero [const_err]
//~| WARN const_err
//~^ WARN [unconditional_panic]
//~| WARN panic or abort [const_err]
//~| WARN erroneous constant used [const_err]
let _x = 1 / (1 - 1);
//~^ WARN const_err
//~^ WARN [unconditional_panic]
println!("{}", 1 / (false as u32));
//~^ WARN attempt to divide by zero [const_err]
//~| WARN const_err
//~^ WARN [unconditional_panic]
//~| WARN panic or abort [const_err]
//~| WARN erroneous constant used [const_err]
let _x = 1 / (false as u32);
//~^ WARN const_err
//~^ WARN [unconditional_panic]
}

60
src/test/ui/consts/const-eval/promoted_errors.stderr
View file

@ -1,60 +0,0 @@
warning: this expression will panic at runtime
--> $DIR/promoted_errors.rs:9:14
|
LL | let _x = 0u32 - 1;
| ^^^^^^^^ attempt to subtract with overflow
|
note: the lint level is defined here
--> $DIR/promoted_errors.rs:5:9
|
LL | #![warn(const_err)]
| ^^^^^^^^^
warning: attempt to divide by zero
--> $DIR/promoted_errors.rs:11:20
|
LL | println!("{}", 1 / (1 - 1));
| ^^^^^^^^^^^
warning: reaching this expression at runtime will panic or abort
--> $DIR/promoted_errors.rs:11:20
|
LL | println!("{}", 1 / (1 - 1));
| ^^^^^^^^^^^ dividing by zero
warning: erroneous constant used
--> $DIR/promoted_errors.rs:11:20
|
LL | println!("{}", 1 / (1 - 1));
| ^^^^^^^^^^^ referenced constant has errors
warning: attempt to divide by zero
--> $DIR/promoted_errors.rs:15:14
|
LL | let _x = 1 / (1 - 1);
| ^^^^^^^^^^^
warning: attempt to divide by zero
--> $DIR/promoted_errors.rs:17:20
|
LL | println!("{}", 1 / (false as u32));
| ^^^^^^^^^^^^^^^^^^
warning: reaching this expression at runtime will panic or abort
--> $DIR/promoted_errors.rs:17:20
|
LL | println!("{}", 1 / (false as u32));
| ^^^^^^^^^^^^^^^^^^ dividing by zero
warning: erroneous constant used
--> $DIR/promoted_errors.rs:17:20
|
LL | println!("{}", 1 / (false as u32));
| ^^^^^^^^^^^^^^^^^^ referenced constant has errors
warning: attempt to divide by zero
--> $DIR/promoted_errors.rs:21:14
|
LL | let _x = 1 / (false as u32);
| ^^^^^^^^^^^^^^^^^^

24
src/test/ui/consts/const-eval/promoted_errors2.rs
View file

@ -1,24 +0,0 @@
// build-pass
// ignore-pass (emit codegen-time warnings and verify that they are indeed warnings and not errors)
// compile-flags: -C overflow-checks=on -O
#![warn(const_err)]
fn main() {
println!("{}", 0u32 - 1);
//~^ WARN attempt to subtract with overflow
let _x = 0u32 - 1;
//~^ WARN attempt to subtract with overflow
println!("{}", 1 / (1 - 1));
//~^ WARN attempt to divide by zero [const_err]
//~| WARN const_err
//~| WARN erroneous constant used [const_err]
let _x = 1 / (1 - 1);
//~^ WARN const_err
println!("{}", 1 / (false as u32));
//~^ WARN attempt to divide by zero [const_err]
//~| WARN const_err
//~| WARN erroneous constant used [const_err]
let _x = 1 / (false as u32);
//~^ WARN const_err
}

66
src/test/ui/consts/const-eval/promoted_errors2.stderr
View file

@ -1,66 +0,0 @@
warning: attempt to subtract with overflow
--> $DIR/promoted_errors2.rs:8:20
|
LL | println!("{}", 0u32 - 1);
| ^^^^^^^^
|
note: the lint level is defined here
--> $DIR/promoted_errors2.rs:5:9
|
LL | #![warn(const_err)]
| ^^^^^^^^^
warning: attempt to subtract with overflow
--> $DIR/promoted_errors2.rs:10:14
|
LL | let _x = 0u32 - 1;
| ^^^^^^^^
warning: attempt to divide by zero
--> $DIR/promoted_errors2.rs:12:20
|
LL | println!("{}", 1 / (1 - 1));
| ^^^^^^^^^^^
warning: reaching this expression at runtime will panic or abort
--> $DIR/promoted_errors2.rs:12:20
|
LL | println!("{}", 1 / (1 - 1));
| ^^^^^^^^^^^ dividing by zero
warning: erroneous constant used
--> $DIR/promoted_errors2.rs:12:20
|
LL | println!("{}", 1 / (1 - 1));
| ^^^^^^^^^^^ referenced constant has errors
warning: attempt to divide by zero
--> $DIR/promoted_errors2.rs:16:14
|
LL | let _x = 1 / (1 - 1);
| ^^^^^^^^^^^
warning: attempt to divide by zero
--> $DIR/promoted_errors2.rs:18:20
|
LL | println!("{}", 1 / (false as u32));
| ^^^^^^^^^^^^^^^^^^
warning: reaching this expression at runtime will panic or abort
--> $DIR/promoted_errors2.rs:18:20
|
LL | println!("{}", 1 / (false as u32));
| ^^^^^^^^^^^^^^^^^^ dividing by zero
warning: erroneous constant used
--> $DIR/promoted_errors2.rs:18:20
|
LL | println!("{}", 1 / (false as u32));
| ^^^^^^^^^^^^^^^^^^ referenced constant has errors
warning: attempt to divide by zero
--> $DIR/promoted_errors2.rs:22:14
|
LL | let _x = 1 / (false as u32);
| ^^^^^^^^^^^^^^^^^^

2
src/test/ui/consts/const-prop-ice.rs
View file

@ -1,5 +1,5 @@
// build-fail
fn main() {
[0; 3][3u64 as usize]; //~ ERROR the len is 3 but the index is 3
[0; 3][3u64 as usize]; //~ ERROR this operation will panic at runtime
}

6
src/test/ui/consts/const-prop-ice.stderr
View file

@ -1,10 +1,10 @@
error: index out of bounds: the len is 3 but the index is 3
error: this operation will panic at runtime
--> $DIR/const-prop-ice.rs:4:5
|
LL | [0; 3][3u64 as usize];
| ^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^ index out of bounds: the len is 3 but the index is 3
|
= note: `#[deny(const_err)]` on by default
= note: `#[deny(unconditional_panic)]` on by default
error: aborting due to previous error

2
src/test/ui/consts/const-prop-ice2.rs
View file

@ -3,5 +3,5 @@
fn main() {
enum Enum { One=1 }
let xs=[0;1 as usize];
println!("{}", xs[Enum::One as usize]); //~ ERROR the len is 1 but the index is 1
println!("{}", xs[Enum::One as usize]); //~ ERROR this operation will panic at runtime
}

6
src/test/ui/consts/const-prop-ice2.stderr
View file

@ -1,10 +1,10 @@
error: index out of bounds: the len is 1 but the index is 1
error: this operation will panic at runtime
--> $DIR/const-prop-ice2.rs:6:20
|
LL | println!("{}", xs[Enum::One as usize]);
| ^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^ index out of bounds: the len is 1 but the index is 1
|
= note: `#[deny(const_err)]` on by default
= note: `#[deny(unconditional_panic)]` on by default
error: aborting due to previous error

6
src/test/ui/consts/issue-64059-2.rs
View file

@ -1,6 +0,0 @@
// compile-flags: -C overflow-checks=on -O
// run-pass
fn main() {
let _ = -(-0.0);
}

5
src/test/ui/consts/issue-64059.rs
View file

@ -1,3 +1,8 @@
// revisions: noopt opt opt_with_overflow_checks
//[noopt]compile-flags: -C opt-level=0
//[opt]compile-flags: -O
//[opt_with_overflow_checks]compile-flags: -C overflow-checks=on -O
// run-pass
fn main() {

30
src/test/ui/consts/issue-69020.noopt.stderr Normal file
View file

@ -0,0 +1,30 @@
error: this arithmetic operation will overflow
--> $DIR/issue-69020.rs:21:22
|
LL | const NEG: i32 = -i32::MIN + T::NEG;
| ^^^^^^^^^ attempt to negate with overflow
|
= note: `#[deny(arithmetic_overflow)]` on by default
error: this arithmetic operation will overflow
--> $DIR/issue-69020.rs:23:22
|
LL | const ADD: i32 = (i32::MAX+1) + T::ADD;
| ^^^^^^^^^^^^ attempt to add with overflow
error: this operation will panic at runtime
--> $DIR/issue-69020.rs:25:22
|
LL | const DIV: i32 = (1/0) + T::DIV;
| ^^^^^ attempt to divide by zero
|
= note: `#[deny(unconditional_panic)]` on by default
error: this operation will panic at runtime
--> $DIR/issue-69020.rs:27:22
|
LL | const OOB: i32 = [1][1] + T::OOB;
| ^^^^^^ index out of bounds: the len is 1 but the index is 1
error: aborting due to 4 previous errors

30
src/test/ui/consts/issue-69020.opt.stderr Normal file
View file

@ -0,0 +1,30 @@
error: this arithmetic operation will overflow
--> $DIR/issue-69020.rs:21:22
|
LL | const NEG: i32 = -i32::MIN + T::NEG;
| ^^^^^^^^^ attempt to negate with overflow
|
= note: `#[deny(arithmetic_overflow)]` on by default
error: this arithmetic operation will overflow
--> $DIR/issue-69020.rs:23:22
|
LL | const ADD: i32 = (i32::MAX+1) + T::ADD;
| ^^^^^^^^^^^^ attempt to add with overflow
error: this operation will panic at runtime
--> $DIR/issue-69020.rs:25:22
|
LL | const DIV: i32 = (1/0) + T::DIV;
| ^^^^^ attempt to divide by zero
|
= note: `#[deny(unconditional_panic)]` on by default
error: this operation will panic at runtime
--> $DIR/issue-69020.rs:27:22
|
LL | const OOB: i32 = [1][1] + T::OOB;
| ^^^^^^ index out of bounds: the len is 1 but the index is 1
error: aborting due to 4 previous errors

30
src/test/ui/consts/issue-69020.opt_with_overflow_checks.stderr Normal file
View file

@ -0,0 +1,30 @@
error: this arithmetic operation will overflow
--> $DIR/issue-69020.rs:21:22
|
LL | const NEG: i32 = -i32::MIN + T::NEG;
| ^^^^^^^^^ attempt to negate with overflow
|
= note: `#[deny(arithmetic_overflow)]` on by default
error: this arithmetic operation will overflow
--> $DIR/issue-69020.rs:23:22
|
LL | const ADD: i32 = (i32::MAX+1) + T::ADD;
| ^^^^^^^^^^^^ attempt to add with overflow
error: this operation will panic at runtime
--> $DIR/issue-69020.rs:25:22
|
LL | const DIV: i32 = (1/0) + T::DIV;
| ^^^^^ attempt to divide by zero
|
= note: `#[deny(unconditional_panic)]` on by default
error: this operation will panic at runtime
--> $DIR/issue-69020.rs:27:22
|
LL | const OOB: i32 = [1][1] + T::OOB;
| ^^^^^^ index out of bounds: the len is 1 but the index is 1
error: aborting due to 4 previous errors

29
src/test/ui/consts/issue-69020.rs Normal file
View file

@ -0,0 +1,29 @@
// revisions: noopt opt opt_with_overflow_checks
//[noopt]compile-flags: -C opt-level=0
//[opt]compile-flags: -O
//[opt_with_overflow_checks]compile-flags: -C overflow-checks=on -O
#![crate_type="lib"]
use std::i32;
pub trait Foo {
const NEG: i32;
const ADD: i32;
const DIV: i32;
const OOB: i32;
}
// These constants cannot be evaluated already (they depend on `T::N`), so
// they can just be linted like normal run-time code. But codegen works
// a bit different in const context, so this test makes sure that we still catch overflow.
impl<T: Foo> Foo for Vec<T> {
const NEG: i32 = -i32::MIN + T::NEG;
//~^ ERROR arithmetic operation will overflow
const ADD: i32 = (i32::MAX+1) + T::ADD;
//~^ ERROR arithmetic operation will overflow
const DIV: i32 = (1/0) + T::DIV;
//~^ ERROR operation will panic
const OOB: i32 = [1][1] + T::OOB;
//~^ ERROR operation will panic
}

2
src/test/ui/huge-array-simple-32.rs
View file

@ -4,7 +4,7 @@
// FIXME https://github.com/rust-lang/rust/issues/59774
// normalize-stderr-test "thread.*panicked.*Metadata module not compiled.*\n" -> ""
// normalize-stderr-test "note:.*RUST_BACKTRACE=1.*\n" -> ""
#![allow(exceeding_bitshifts)]
#![allow(arithmetic_overflow)]
fn main() {
let _fat: [u8; (1<<31)+(1<<15)] = //~ ERROR too big for the current architecture

2
src/test/ui/huge-array-simple-64.rs
View file

@ -4,7 +4,7 @@
// FIXME https://github.com/rust-lang/rust/issues/59774
// normalize-stderr-test "thread.*panicked.*Metadata module not compiled.*\n" -> ""
// normalize-stderr-test "note:.*RUST_BACKTRACE=1.*\n" -> ""
#![allow(exceeding_bitshifts)]
#![allow(arithmetic_overflow)]
fn main() {
let _fat: [u8; (1<<61)+(1<<31)] = //~ ERROR too big for the current architecture

4
src/test/ui/issues/issue-54348.rs
View file

@ -2,6 +2,6 @@
fn main() {
[1][0u64 as usize];
[1][1.5 as usize]; //~ ERROR index out of bounds
[1][1u64 as usize]; //~ ERROR index out of bounds
[1][1.5 as usize]; //~ ERROR operation will panic
[1][1u64 as usize]; //~ ERROR operation will panic
}

10
src/test/ui/issues/issue-54348.stderr
View file

@ -1,16 +1,16 @@
error: index out of bounds: the len is 1 but the index is 1
error: this operation will panic at runtime
--> $DIR/issue-54348.rs:5:5
|
LL | [1][1.5 as usize];
| ^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^ index out of bounds: the len is 1 but the index is 1
|
= note: `#[deny(const_err)]` on by default
= note: `#[deny(unconditional_panic)]` on by default
error: index out of bounds: the len is 1 but the index is 1
error: this operation will panic at runtime
--> $DIR/issue-54348.rs:6:5
|
LL | [1][1u64 as usize];
| ^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^ index out of bounds: the len is 1 but the index is 1
error: aborting due to 2 previous errors

150
src/test/ui/issues/issue-8460-const.noopt.stderr Normal file
View file

@ -0,0 +1,150 @@
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:14:36
|
LL | assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^^ attempt to divide with overflow
|
= note: `#[deny(arithmetic_overflow)]` on by default
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:16:36
|
LL | assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^ attempt to divide with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:18:36
|
LL | assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to divide with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:20:36
|
LL | assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to divide with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:22:36
|
LL | assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to divide with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:24:36
|
LL | assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^ attempt to divide with overflow
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:26:36
|
LL | assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
| ^^^^^^^^^^ attempt to divide by zero
|
= note: `#[deny(unconditional_panic)]` on by default
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:28:36
|
LL | assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
| ^^^^^^^ attempt to divide by zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:30:36
|
LL | assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide by zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:32:36
|
LL | assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide by zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:34:36
|
LL | assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide by zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:36:36
|
LL | assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
| ^^^^^^^^^ attempt to divide by zero
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:38:36
|
LL | assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:40:36
|
LL | assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:42:36
|
LL | assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:44:36
|
LL | assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:46:36
|
LL | assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:48:36
|
LL | assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:50:36
|
LL | assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
| ^^^^^^^^^^ attempt to calculate the remainder with a divisor of zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:52:36
|
LL | assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
| ^^^^^^^ attempt to calculate the remainder with a divisor of zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:54:36
|
LL | assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:56:36
|
LL | assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:58:36
|
LL | assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:60:36
|
LL | assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
| ^^^^^^^^^ attempt to calculate the remainder with a divisor of zero
error: aborting due to 24 previous errors

150
src/test/ui/issues/issue-8460-const.opt.stderr Normal file
View file

@ -0,0 +1,150 @@
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:14:36
|
LL | assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^^ attempt to divide with overflow
|
= note: `#[deny(arithmetic_overflow)]` on by default
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:16:36
|
LL | assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^ attempt to divide with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:18:36
|
LL | assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to divide with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:20:36
|
LL | assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to divide with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:22:36
|
LL | assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to divide with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:24:36
|
LL | assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^ attempt to divide with overflow
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:26:36
|
LL | assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
| ^^^^^^^^^^ attempt to divide by zero
|
= note: `#[deny(unconditional_panic)]` on by default
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:28:36
|
LL | assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
| ^^^^^^^ attempt to divide by zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:30:36
|
LL | assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide by zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:32:36
|
LL | assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide by zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:34:36
|
LL | assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide by zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:36:36
|
LL | assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
| ^^^^^^^^^ attempt to divide by zero
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:38:36
|
LL | assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:40:36
|
LL | assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:42:36
|
LL | assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:44:36
|
LL | assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:46:36
|
LL | assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:48:36
|
LL | assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:50:36
|
LL | assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
| ^^^^^^^^^^ attempt to calculate the remainder with a divisor of zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:52:36
|
LL | assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
| ^^^^^^^ attempt to calculate the remainder with a divisor of zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:54:36
|
LL | assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:56:36
|
LL | assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:58:36
|
LL | assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:60:36
|
LL | assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
| ^^^^^^^^^ attempt to calculate the remainder with a divisor of zero
error: aborting due to 24 previous errors

150
src/test/ui/issues/issue-8460-const.opt_with_overflow_checks.stderr Normal file
View file

@ -0,0 +1,150 @@
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:14:36
|
LL | assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^^ attempt to divide with overflow
|
= note: `#[deny(arithmetic_overflow)]` on by default
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:16:36
|
LL | assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^ attempt to divide with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:18:36
|
LL | assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to divide with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:20:36
|
LL | assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to divide with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:22:36
|
LL | assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to divide with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:24:36
|
LL | assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^ attempt to divide with overflow
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:26:36
|
LL | assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
| ^^^^^^^^^^ attempt to divide by zero
|
= note: `#[deny(unconditional_panic)]` on by default
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:28:36
|
LL | assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
| ^^^^^^^ attempt to divide by zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:30:36
|
LL | assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide by zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:32:36
|
LL | assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide by zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:34:36
|
LL | assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide by zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:36:36
|
LL | assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
| ^^^^^^^^^ attempt to divide by zero
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:38:36
|
LL | assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:40:36
|
LL | assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:42:36
|
LL | assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:44:36
|
LL | assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:46:36
|
LL | assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: this arithmetic operation will overflow
--> $DIR/issue-8460-const.rs:48:36
|
LL | assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:50:36
|
LL | assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
| ^^^^^^^^^^ attempt to calculate the remainder with a divisor of zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:52:36
|
LL | assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
| ^^^^^^^ attempt to calculate the remainder with a divisor of zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:54:36
|
LL | assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:56:36
|
LL | assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:58:36
|
LL | assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
error: this operation will panic at runtime
--> $DIR/issue-8460-const.rs:60:36
|
LL | assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
| ^^^^^^^^^ attempt to calculate the remainder with a divisor of zero
error: aborting due to 24 previous errors

66
src/test/ui/issues/issue-8460-const.rs
View file

@ -1,5 +1,9 @@
// revisions: noopt opt opt_with_overflow_checks
//[noopt]compile-flags: -C opt-level=0
//[opt]compile-flags: -O
//[opt_with_overflow_checks]compile-flags: -C overflow-checks=on -O
// build-fail
// compile-flags: -O
#![deny(const_err)]
@ -8,63 +12,51 @@ use std::thread;
fn main() {
assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
//~^ ERROR attempt to divide with overflow
//~| ERROR this expression will panic at runtime
//~^ ERROR arithmetic operation will overflow
assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
//~^ ERROR attempt to divide with overflow
//~| ERROR this expression will panic at runtime
//~^ ERROR arithmetic operation will overflow
assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
//~^ ERROR attempt to divide with overflow
//~| ERROR this expression will panic at runtime
//~^ ERROR arithmetic operation will overflow
assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
//~^ ERROR attempt to divide with overflow
//~| ERROR this expression will panic at runtime
//~^ ERROR arithmetic operation will overflow
assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
//~^ ERROR attempt to divide with overflow
//~| ERROR this expression will panic at runtime
//~^ ERROR arithmetic operation will overflow
assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
//~^ ERROR attempt to divide with overflow
//~| ERROR this expression will panic at runtime
//~^ ERROR arithmetic operation will overflow
assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
//~^ ERROR attempt to divide by zero
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
//~^ ERROR attempt to divide by zero
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
//~^ ERROR attempt to divide by zero
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
//~^ ERROR attempt to divide by zero
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
//~^ ERROR attempt to divide by zero
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
//~^ ERROR attempt to divide by zero
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with overflow
//~| ERROR this expression will panic at runtime
//~^ ERROR arithmetic operation will overflow
assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with overflow
//~| ERROR this expression will panic at runtime
//~^ ERROR arithmetic operation will overflow
assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with overflow
//~| ERROR this expression will panic at runtime
//~^ ERROR arithmetic operation will overflow
assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with overflow
//~| ERROR this expression will panic at runtime
//~^ ERROR arithmetic operation will overflow
assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with overflow
//~| ERROR this expression will panic at runtime
//~^ ERROR arithmetic operation will overflow
assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with overflow
//~| ERROR this expression will panic at runtime
//~^ ERROR arithmetic operation will overflow
assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with a divisor of zero
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with a divisor of zero
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with a divisor of zero
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with a divisor of zero
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with a divisor of zero
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with a divisor of zero
//~^ ERROR operation will panic
}

224
src/test/ui/issues/issue-8460-const.stderr
View file

@ -1,224 +0,0 @@
error: attempt to divide with overflow
--> $DIR/issue-8460-const.rs:10:36
|
LL | assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^^
|
note: the lint level is defined here
--> $DIR/issue-8460-const.rs:4:9
|
LL | #![deny(const_err)]
| ^^^^^^^^^
error: this expression will panic at runtime
--> $DIR/issue-8460-const.rs:10:36
|
LL | assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^^ attempt to divide with overflow
error: attempt to divide with overflow
--> $DIR/issue-8460-const.rs:13:36
|
LL | assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^
error: this expression will panic at runtime
--> $DIR/issue-8460-const.rs:13:36
|
LL | assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^ attempt to divide with overflow
error: attempt to divide with overflow
--> $DIR/issue-8460-const.rs:16:36
|
LL | assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^
error: this expression will panic at runtime
--> $DIR/issue-8460-const.rs:16:36
|
LL | assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to divide with overflow
error: attempt to divide with overflow
--> $DIR/issue-8460-const.rs:19:36
|
LL | assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^
error: this expression will panic at runtime
--> $DIR/issue-8460-const.rs:19:36
|
LL | assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to divide with overflow
error: attempt to divide with overflow
--> $DIR/issue-8460-const.rs:22:36
|
LL | assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^
error: this expression will panic at runtime
--> $DIR/issue-8460-const.rs:22:36
|
LL | assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to divide with overflow
error: attempt to divide with overflow
--> $DIR/issue-8460-const.rs:25:36
|
LL | assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^
error: this expression will panic at runtime
--> $DIR/issue-8460-const.rs:25:36
|
LL | assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^ attempt to divide with overflow
error: attempt to divide by zero
--> $DIR/issue-8460-const.rs:28:36
|
LL | assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
| ^^^^^^^^^^
error: attempt to divide by zero
--> $DIR/issue-8460-const.rs:30:36
|
LL | assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
| ^^^^^^^
error: attempt to divide by zero
--> $DIR/issue-8460-const.rs:32:36
|
LL | assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
| ^^^^^^^^
error: attempt to divide by zero
--> $DIR/issue-8460-const.rs:34:36
|
LL | assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
| ^^^^^^^^
error: attempt to divide by zero
--> $DIR/issue-8460-const.rs:36:36
|
LL | assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
| ^^^^^^^^
error: attempt to divide by zero
--> $DIR/issue-8460-const.rs:38:36
|
LL | assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
| ^^^^^^^^^
error: attempt to calculate the remainder with overflow
--> $DIR/issue-8460-const.rs:40:36
|
LL | assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^^
error: this expression will panic at runtime
--> $DIR/issue-8460-const.rs:40:36
|
LL | assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: attempt to calculate the remainder with overflow
--> $DIR/issue-8460-const.rs:43:36
|
LL | assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^
error: this expression will panic at runtime
--> $DIR/issue-8460-const.rs:43:36
|
LL | assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: attempt to calculate the remainder with overflow
--> $DIR/issue-8460-const.rs:46:36
|
LL | assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^
error: this expression will panic at runtime
--> $DIR/issue-8460-const.rs:46:36
|
LL | assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: attempt to calculate the remainder with overflow
--> $DIR/issue-8460-const.rs:49:36
|
LL | assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^
error: this expression will panic at runtime
--> $DIR/issue-8460-const.rs:49:36
|
LL | assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: attempt to calculate the remainder with overflow
--> $DIR/issue-8460-const.rs:52:36
|
LL | assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^
error: this expression will panic at runtime
--> $DIR/issue-8460-const.rs:52:36
|
LL | assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: attempt to calculate the remainder with overflow
--> $DIR/issue-8460-const.rs:55:36
|
LL | assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^
error: this expression will panic at runtime
--> $DIR/issue-8460-const.rs:55:36
|
LL | assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
error: attempt to calculate the remainder with a divisor of zero
--> $DIR/issue-8460-const.rs:58:36
|
LL | assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
| ^^^^^^^^^^
error: attempt to calculate the remainder with a divisor of zero
--> $DIR/issue-8460-const.rs:60:36
|
LL | assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
| ^^^^^^^
error: attempt to calculate the remainder with a divisor of zero
--> $DIR/issue-8460-const.rs:62:36
|
LL | assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
| ^^^^^^^^
error: attempt to calculate the remainder with a divisor of zero
--> $DIR/issue-8460-const.rs:64:36
|
LL | assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
| ^^^^^^^^
error: attempt to calculate the remainder with a divisor of zero
--> $DIR/issue-8460-const.rs:66:36
|
LL | assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
| ^^^^^^^^
error: attempt to calculate the remainder with a divisor of zero
--> $DIR/issue-8460-const.rs:68:36
|
LL | assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
| ^^^^^^^^^
error: aborting due to 36 previous errors

58
src/test/ui/issues/issue-8460-const2.rs
View file

@ -1,58 +0,0 @@
// build-fail
// compile-flags: -C overflow-checks=on -O
#![deny(const_err)]
use std::{isize, i8, i16, i32, i64, i128};
use std::thread;
fn main() {
assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
//~^ ERROR attempt to divide with overflow
assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
//~^ ERROR attempt to divide with overflow
assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
//~^ ERROR attempt to divide with overflow
assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
//~^ ERROR attempt to divide with overflow
assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
//~^ ERROR attempt to divide with overflow
assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
//~^ ERROR attempt to divide with overflow
assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
//~^ ERROR attempt to divide by zero
assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
//~^ ERROR attempt to divide by zero
assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
//~^ ERROR attempt to divide by zero
assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
//~^ ERROR attempt to divide by zero
assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
//~^ ERROR attempt to divide by zero
assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
//~^ ERROR attempt to divide by zero
assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with overflow
assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with overflow
assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with overflow
assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with overflow
assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with overflow
assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with overflow
assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with a divisor of zero
assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with a divisor of zero
assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with a divisor of zero
assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with a divisor of zero
assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with a divisor of zero
assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
//~^ ERROR attempt to calculate the remainder with a divisor of zero
}

152
src/test/ui/issues/issue-8460-const2.stderr
View file

@ -1,152 +0,0 @@
error: attempt to divide with overflow
--> $DIR/issue-8460-const2.rs:10:36
|
LL | assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^^
|
note: the lint level is defined here
--> $DIR/issue-8460-const2.rs:4:9
|
LL | #![deny(const_err)]
| ^^^^^^^^^
error: attempt to divide with overflow
--> $DIR/issue-8460-const2.rs:12:36
|
LL | assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^
error: attempt to divide with overflow
--> $DIR/issue-8460-const2.rs:14:36
|
LL | assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^
error: attempt to divide with overflow
--> $DIR/issue-8460-const2.rs:16:36
|
LL | assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^
error: attempt to divide with overflow
--> $DIR/issue-8460-const2.rs:18:36
|
LL | assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^
error: attempt to divide with overflow
--> $DIR/issue-8460-const2.rs:20:36
|
LL | assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^
error: attempt to divide by zero
--> $DIR/issue-8460-const2.rs:22:36
|
LL | assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
| ^^^^^^^^^^
error: attempt to divide by zero
--> $DIR/issue-8460-const2.rs:24:36
|
LL | assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
| ^^^^^^^
error: attempt to divide by zero
--> $DIR/issue-8460-const2.rs:26:36
|
LL | assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
| ^^^^^^^^
error: attempt to divide by zero
--> $DIR/issue-8460-const2.rs:28:36
|
LL | assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
| ^^^^^^^^
error: attempt to divide by zero
--> $DIR/issue-8460-const2.rs:30:36
|
LL | assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
| ^^^^^^^^
error: attempt to divide by zero
--> $DIR/issue-8460-const2.rs:32:36
|
LL | assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
| ^^^^^^^^^
error: attempt to calculate the remainder with overflow
--> $DIR/issue-8460-const2.rs:34:36
|
LL | assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^^
error: attempt to calculate the remainder with overflow
--> $DIR/issue-8460-const2.rs:36:36
|
LL | assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^
error: attempt to calculate the remainder with overflow
--> $DIR/issue-8460-const2.rs:38:36
|
LL | assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^
error: attempt to calculate the remainder with overflow
--> $DIR/issue-8460-const2.rs:40:36
|
LL | assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^
error: attempt to calculate the remainder with overflow
--> $DIR/issue-8460-const2.rs:42:36
|
LL | assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^
error: attempt to calculate the remainder with overflow
--> $DIR/issue-8460-const2.rs:44:36
|
LL | assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^
error: attempt to calculate the remainder with a divisor of zero
--> $DIR/issue-8460-const2.rs:46:36
|
LL | assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
| ^^^^^^^^^^
error: attempt to calculate the remainder with a divisor of zero
--> $DIR/issue-8460-const2.rs:48:36
|
LL | assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
| ^^^^^^^
error: attempt to calculate the remainder with a divisor of zero
--> $DIR/issue-8460-const2.rs:50:36
|
LL | assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
| ^^^^^^^^
error: attempt to calculate the remainder with a divisor of zero
--> $DIR/issue-8460-const2.rs:52:36
|
LL | assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
| ^^^^^^^^
error: attempt to calculate the remainder with a divisor of zero
--> $DIR/issue-8460-const2.rs:54:36
|
LL | assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
| ^^^^^^^^
error: attempt to calculate the remainder with a divisor of zero
--> $DIR/issue-8460-const2.rs:56:36
|
LL | assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
| ^^^^^^^^^
error: aborting due to 24 previous errors

146
src/test/ui/lint/lint-exceeding-bitshifts.noopt.stderr Normal file
View file

@ -0,0 +1,146 @@
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:22:13
|
LL | let _ = x << 42;
| ^^^^^^^ attempt to shift left with overflow
|
note: the lint level is defined here
--> $DIR/lint-exceeding-bitshifts.rs:9:9
|
LL | #![deny(arithmetic_overflow, const_err)]
| ^^^^^^^^^^^^^^^^^^^
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:27:15
|
LL | let n = 1u8 << 8;
| ^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:29:15
|
LL | let n = 1u16 << 16;
| ^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:31:15
|
LL | let n = 1u32 << 32;
| ^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:33:15
|
LL | let n = 1u64 << 64;
| ^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:35:15
|
LL | let n = 1i8 << 8;
| ^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:37:15
|
LL | let n = 1i16 << 16;
| ^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:39:15
|
LL | let n = 1i32 << 32;
| ^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:41:15
|
LL | let n = 1i64 << 64;
| ^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:44:15
|
LL | let n = 1u8 >> 8;
| ^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:46:15
|
LL | let n = 1u16 >> 16;
| ^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:48:15
|
LL | let n = 1u32 >> 32;
| ^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:50:15
|
LL | let n = 1u64 >> 64;
| ^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:52:15
|
LL | let n = 1i8 >> 8;
| ^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:54:15
|
LL | let n = 1i16 >> 16;
| ^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:56:15
|
LL | let n = 1i32 >> 32;
| ^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:58:15
|
LL | let n = 1i64 >> 64;
| ^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:62:15
|
LL | let n = n << 8;
| ^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:64:15
|
LL | let n = 1u8 << -8;
| ^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:69:15
|
LL | let n = 1u8 << (4+4);
| ^^^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:71:15
|
LL | let n = 1i64 >> [64][0];
| ^^^^^^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:77:15
|
LL | let n = 1_isize << BITS;
| ^^^^^^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:78:15
|
LL | let n = 1_usize << BITS;
| ^^^^^^^^^^^^^^^ attempt to shift left with overflow
error: aborting due to 23 previous errors

146
src/test/ui/lint/lint-exceeding-bitshifts.opt.stderr Normal file
View file

@ -0,0 +1,146 @@
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:22:13
|
LL | let _ = x << 42;
| ^^^^^^^ attempt to shift left with overflow
|
note: the lint level is defined here
--> $DIR/lint-exceeding-bitshifts.rs:9:9
|
LL | #![deny(arithmetic_overflow, const_err)]
| ^^^^^^^^^^^^^^^^^^^
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:27:15
|
LL | let n = 1u8 << 8;
| ^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:29:15
|
LL | let n = 1u16 << 16;
| ^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:31:15
|
LL | let n = 1u32 << 32;
| ^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:33:15
|
LL | let n = 1u64 << 64;
| ^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:35:15
|
LL | let n = 1i8 << 8;
| ^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:37:15
|
LL | let n = 1i16 << 16;
| ^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:39:15
|
LL | let n = 1i32 << 32;
| ^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:41:15
|
LL | let n = 1i64 << 64;
| ^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:44:15
|
LL | let n = 1u8 >> 8;
| ^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:46:15
|
LL | let n = 1u16 >> 16;
| ^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:48:15
|
LL | let n = 1u32 >> 32;
| ^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:50:15
|
LL | let n = 1u64 >> 64;
| ^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:52:15
|
LL | let n = 1i8 >> 8;
| ^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:54:15
|
LL | let n = 1i16 >> 16;
| ^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:56:15
|
LL | let n = 1i32 >> 32;
| ^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:58:15
|
LL | let n = 1i64 >> 64;
| ^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:62:15
|
LL | let n = n << 8;
| ^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:64:15
|
LL | let n = 1u8 << -8;
| ^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:69:15
|
LL | let n = 1u8 << (4+4);
| ^^^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:71:15
|
LL | let n = 1i64 >> [64][0];
| ^^^^^^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:77:15
|
LL | let n = 1_isize << BITS;
| ^^^^^^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:78:15
|
LL | let n = 1_usize << BITS;
| ^^^^^^^^^^^^^^^ attempt to shift left with overflow
error: aborting due to 23 previous errors

146
src/test/ui/lint/lint-exceeding-bitshifts.opt_with_overflow_checks.stderr Normal file
View file

@ -0,0 +1,146 @@
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:22:13
|
LL | let _ = x << 42;
| ^^^^^^^ attempt to shift left with overflow
|
note: the lint level is defined here
--> $DIR/lint-exceeding-bitshifts.rs:9:9
|
LL | #![deny(arithmetic_overflow, const_err)]
| ^^^^^^^^^^^^^^^^^^^
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:27:15
|
LL | let n = 1u8 << 8;
| ^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:29:15
|
LL | let n = 1u16 << 16;
| ^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:31:15
|
LL | let n = 1u32 << 32;
| ^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:33:15
|
LL | let n = 1u64 << 64;
| ^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:35:15
|
LL | let n = 1i8 << 8;
| ^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:37:15
|
LL | let n = 1i16 << 16;
| ^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:39:15
|
LL | let n = 1i32 << 32;
| ^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:41:15
|
LL | let n = 1i64 << 64;
| ^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:44:15
|
LL | let n = 1u8 >> 8;
| ^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:46:15
|
LL | let n = 1u16 >> 16;
| ^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:48:15
|
LL | let n = 1u32 >> 32;
| ^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:50:15
|
LL | let n = 1u64 >> 64;
| ^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:52:15
|
LL | let n = 1i8 >> 8;
| ^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:54:15
|
LL | let n = 1i16 >> 16;
| ^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:56:15
|
LL | let n = 1i32 >> 32;
| ^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:58:15
|
LL | let n = 1i64 >> 64;
| ^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:62:15
|
LL | let n = n << 8;
| ^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:64:15
|
LL | let n = 1u8 << -8;
| ^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:69:15
|
LL | let n = 1u8 << (4+4);
| ^^^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:71:15
|
LL | let n = 1i64 >> [64][0];
| ^^^^^^^^^^^^^^^ attempt to shift right with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:77:15
|
LL | let n = 1_isize << BITS;
| ^^^^^^^^^^^^^^^ attempt to shift left with overflow
error: this arithmetic operation will overflow
--> $DIR/lint-exceeding-bitshifts.rs:78:15
|
LL | let n = 1_usize << BITS;
| ^^^^^^^^^^^^^^^ attempt to shift left with overflow
error: aborting due to 23 previous errors

73
src/test/ui/lint/lint-exceeding-bitshifts.rs
View file

@ -1,50 +1,79 @@
// build-fail
// compile-flags: -O
// revisions: noopt opt opt_with_overflow_checks
//[noopt]compile-flags: -C opt-level=0
//[opt]compile-flags: -O
//[opt_with_overflow_checks]compile-flags: -C overflow-checks=on -O
#![deny(exceeding_bitshifts, const_err)]
// build-fail
#![crate_type="lib"]
#![deny(arithmetic_overflow, const_err)]
#![allow(unused_variables)]
#![allow(dead_code)]
fn main() {
pub trait Foo {
const N: i32;
}
impl<T: Foo> Foo for Vec<T> {
const N: i32 = T::N << 42; // FIXME this should warn
}
pub fn foo(x: i32) {
let _ = x << 42; //~ ERROR: arithmetic operation will overflow
}
pub fn main() {
let n = 1u8 << 7;
let n = 1u8 << 8; //~ ERROR: attempt to shift left with overflow
let n = 1u8 << 8; //~ ERROR: arithmetic operation will overflow
let n = 1u16 << 15;
let n = 1u16 << 16; //~ ERROR: attempt to shift left with overflow
let n = 1u16 << 16; //~ ERROR: arithmetic operation will overflow
let n = 1u32 << 31;
let n = 1u32 << 32; //~ ERROR: attempt to shift left with overflow
let n = 1u32 << 32; //~ ERROR: arithmetic operation will overflow
let n = 1u64 << 63;
let n = 1u64 << 64; //~ ERROR: attempt to shift left with overflow
let n = 1u64 << 64; //~ ERROR: arithmetic operation will overflow
let n = 1i8 << 7;
let n = 1i8 << 8; //~ ERROR: attempt to shift left with overflow
let n = 1i8 << 8; //~ ERROR: arithmetic operation will overflow
let n = 1i16 << 15;
let n = 1i16 << 16; //~ ERROR: attempt to shift left with overflow
let n = 1i16 << 16; //~ ERROR: arithmetic operation will overflow
let n = 1i32 << 31;
let n = 1i32 << 32; //~ ERROR: attempt to shift left with overflow
let n = 1i32 << 32; //~ ERROR: arithmetic operation will overflow
let n = 1i64 << 63;
let n = 1i64 << 64; //~ ERROR: attempt to shift left with overflow
let n = 1i64 << 64; //~ ERROR: arithmetic operation will overflow
let n = 1u8 >> 7;
let n = 1u8 >> 8; //~ ERROR: attempt to shift right with overflow
let n = 1u8 >> 8; //~ ERROR: arithmetic operation will overflow
let n = 1u16 >> 15;
let n = 1u16 >> 16; //~ ERROR: attempt to shift right with overflow
let n = 1u16 >> 16; //~ ERROR: arithmetic operation will overflow
let n = 1u32 >> 31;
let n = 1u32 >> 32; //~ ERROR: attempt to shift right with overflow
let n = 1u32 >> 32; //~ ERROR: arithmetic operation will overflow
let n = 1u64 >> 63;
let n = 1u64 >> 64; //~ ERROR: attempt to shift right with overflow
let n = 1u64 >> 64; //~ ERROR: arithmetic operation will overflow
let n = 1i8 >> 7;
let n = 1i8 >> 8; //~ ERROR: attempt to shift right with overflow
let n = 1i8 >> 8; //~ ERROR: arithmetic operation will overflow
let n = 1i16 >> 15;
let n = 1i16 >> 16; //~ ERROR: attempt to shift right with overflow
let n = 1i16 >> 16; //~ ERROR: arithmetic operation will overflow
let n = 1i32 >> 31;
let n = 1i32 >> 32; //~ ERROR: attempt to shift right with overflow
let n = 1i32 >> 32; //~ ERROR: arithmetic operation will overflow
let n = 1i64 >> 63;
let n = 1i64 >> 64; //~ ERROR: attempt to shift right with overflow
let n = 1i64 >> 64; //~ ERROR: arithmetic operation will overflow
let n = 1u8;
let n = n << 7;
let n = n << 8; //~ ERROR: attempt to shift left with overflow
let n = n << 8; //~ ERROR: arithmetic operation will overflow
let n = 1u8 << -8; //~ ERROR: attempt to shift left with overflow
let n = 1u8 << -8; //~ ERROR: arithmetic operation will overflow
let n = 1i8<<(1isize+-1);
let n = 1u8 << (4+3);
let n = 1u8 << (4+4); //~ ERROR: arithmetic operation will overflow
let n = 1i64 >> [63][0];
let n = 1i64 >> [64][0]; //~ ERROR: arithmetic operation will overflow
#[cfg(target_pointer_width = "32")]
const BITS: usize = 32;
#[cfg(target_pointer_width = "64")]
const BITS: usize = 64;
let n = 1_isize << BITS; //~ ERROR: arithmetic operation will overflow
let n = 1_usize << BITS; //~ ERROR: arithmetic operation will overflow
}

116
src/test/ui/lint/lint-exceeding-bitshifts.stderr
View file

@ -1,116 +0,0 @@
error: attempt to shift left with overflow
--> $DIR/lint-exceeding-bitshifts.rs:10:15
|
LL | let n = 1u8 << 8;
| ^^^^^^^^
|
note: the lint level is defined here
--> $DIR/lint-exceeding-bitshifts.rs:4:9
|
LL | #![deny(exceeding_bitshifts, const_err)]
| ^^^^^^^^^^^^^^^^^^^
error: attempt to shift left with overflow
--> $DIR/lint-exceeding-bitshifts.rs:12:15
|
LL | let n = 1u16 << 16;
| ^^^^^^^^^^
error: attempt to shift left with overflow
--> $DIR/lint-exceeding-bitshifts.rs:14:15
|
LL | let n = 1u32 << 32;
| ^^^^^^^^^^
error: attempt to shift left with overflow
--> $DIR/lint-exceeding-bitshifts.rs:16:15
|
LL | let n = 1u64 << 64;
| ^^^^^^^^^^
error: attempt to shift left with overflow
--> $DIR/lint-exceeding-bitshifts.rs:18:15
|
LL | let n = 1i8 << 8;
| ^^^^^^^^
error: attempt to shift left with overflow
--> $DIR/lint-exceeding-bitshifts.rs:20:15
|
LL | let n = 1i16 << 16;
| ^^^^^^^^^^
error: attempt to shift left with overflow
--> $DIR/lint-exceeding-bitshifts.rs:22:15
|
LL | let n = 1i32 << 32;
| ^^^^^^^^^^
error: attempt to shift left with overflow
--> $DIR/lint-exceeding-bitshifts.rs:24:15
|
LL | let n = 1i64 << 64;
| ^^^^^^^^^^
error: attempt to shift right with overflow
--> $DIR/lint-exceeding-bitshifts.rs:27:15
|
LL | let n = 1u8 >> 8;
| ^^^^^^^^
error: attempt to shift right with overflow
--> $DIR/lint-exceeding-bitshifts.rs:29:15
|
LL | let n = 1u16 >> 16;
| ^^^^^^^^^^
error: attempt to shift right with overflow
--> $DIR/lint-exceeding-bitshifts.rs:31:15
|
LL | let n = 1u32 >> 32;
| ^^^^^^^^^^
error: attempt to shift right with overflow
--> $DIR/lint-exceeding-bitshifts.rs:33:15
|
LL | let n = 1u64 >> 64;
| ^^^^^^^^^^
error: attempt to shift right with overflow
--> $DIR/lint-exceeding-bitshifts.rs:35:15
|
LL | let n = 1i8 >> 8;
| ^^^^^^^^
error: attempt to shift right with overflow
--> $DIR/lint-exceeding-bitshifts.rs:37:15
|
LL | let n = 1i16 >> 16;
| ^^^^^^^^^^
error: attempt to shift right with overflow
--> $DIR/lint-exceeding-bitshifts.rs:39:15
|
LL | let n = 1i32 >> 32;
| ^^^^^^^^^^
error: attempt to shift right with overflow
--> $DIR/lint-exceeding-bitshifts.rs:41:15
|
LL | let n = 1i64 >> 64;
| ^^^^^^^^^^
error: attempt to shift left with overflow
--> $DIR/lint-exceeding-bitshifts.rs:45:15
|
LL | let n = n << 8;
| ^^^^^^
error: attempt to shift left with overflow
--> $DIR/lint-exceeding-bitshifts.rs:47:15
|
LL | let n = 1u8 << -8;
| ^^^^^^^^^
error: aborting due to 18 previous errors

20
src/test/ui/lint/lint-exceeding-bitshifts2.rs
View file

@ -1,20 +0,0 @@
// build-fail
// compile-flags: -O
#![deny(exceeding_bitshifts, const_err)]
#![allow(unused_variables)]
#![allow(dead_code)]
fn main() {
let n = 1u8 << (4+3);
let n = 1u8 << (4+4); //~ ERROR: attempt to shift left with overflow
let n = 1i64 >> [63][0];
let n = 1i64 >> [64][0]; //~ ERROR: attempt to shift right with overflow
#[cfg(target_pointer_width = "32")]
const BITS: usize = 32;
#[cfg(target_pointer_width = "64")]
const BITS: usize = 64;
let n = 1_isize << BITS; //~ ERROR: attempt to shift left with overflow
let n = 1_usize << BITS; //~ ERROR: attempt to shift left with overflow
}

32
src/test/ui/lint/lint-exceeding-bitshifts2.stderr
View file

@ -1,32 +0,0 @@
error: attempt to shift left with overflow
--> $DIR/lint-exceeding-bitshifts2.rs:10:15
|
LL | let n = 1u8 << (4+4);
| ^^^^^^^^^^^^
|
note: the lint level is defined here
--> $DIR/lint-exceeding-bitshifts2.rs:4:9
|
LL | #![deny(exceeding_bitshifts, const_err)]
| ^^^^^^^^^^^^^^^^^^^
error: attempt to shift right with overflow
--> $DIR/lint-exceeding-bitshifts2.rs:12:15
|
LL | let n = 1i64 >> [64][0];
| ^^^^^^^^^^^^^^^
error: attempt to shift left with overflow
--> $DIR/lint-exceeding-bitshifts2.rs:18:15
|
LL | let n = 1_isize << BITS;
| ^^^^^^^^^^^^^^^
error: attempt to shift left with overflow
--> $DIR/lint-exceeding-bitshifts2.rs:19:15
|
LL | let n = 1_usize << BITS;
| ^^^^^^^^^^^^^^^
error: aborting due to 4 previous errors