Mirrors/rust
1
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2026-05-28 20:16:58 +03:00
Code Issues Packages Projects Releases Wiki Activity

lint-overflowing-ops: unify cases and remove redundancy

Browse Source
This commit is contained in:
Ralf Jung
2024-02-23 12:28:00 +01:00
parent dda102c190
commit 9a2d550050
4 changed files with 1688 additions and 1173 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/ui/lint/lint-overflowing-ops.noopt.stderr
+510 -365
View File
@@ -13,81 +13,81 @@ LL | #![deny(arithmetic_overflow)]
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:226:15
|
LL | let _n = &(-i8::MIN);
| ^^^^^^^^^^ attempt to negate `i8::MIN`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:223:15
|
LL | let _n = &(usize::MAX * 5);
| ^^^^^^^^^^^^^^^^ attempt to compute `usize::MAX * 5_usize`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:220:15
|
LL | let _n = &(isize::MAX * 5);
| ^^^^^^^^^^^^^^^^ attempt to compute `isize::MAX * 5_isize`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:217:15
--> $DIR/lint-overflowing-ops.rs:223:15
|
LL | let _n = &(i128::MAX * 5);
| ^^^^^^^^^^^^^^^ attempt to compute `i128::MAX * 5_i128`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:214:15
--> $DIR/lint-overflowing-ops.rs:220:15
|
LL | let _n = &(i64::MAX * 5);
| ^^^^^^^^^^^^^^ attempt to compute `i64::MAX * 5_i64`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:211:15
--> $DIR/lint-overflowing-ops.rs:217:15
|
LL | let _n = &(i32::MAX * 5);
| ^^^^^^^^^^^^^^ attempt to compute `i32::MAX * 5_i32`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:208:15
--> $DIR/lint-overflowing-ops.rs:214:15
|
LL | let _n = &(i16::MAX * 5);
| ^^^^^^^^^^^^^^ attempt to compute `i16::MAX * 5_i16`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:205:15
--> $DIR/lint-overflowing-ops.rs:211:15
|
LL | let _n = &(i8::MAX * i8::MAX);
| ^^^^^^^^^^^^^^^^^^^ attempt to compute `i8::MAX * i8::MAX`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:202:15
--> $DIR/lint-overflowing-ops.rs:208:15
|
LL | let _n = &(usize::MAX * 5);
| ^^^^^^^^^^^^^^^^ attempt to compute `usize::MAX * 5_usize`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:205:15
|
LL | let _n = &(u128::MAX * 5);
| ^^^^^^^^^^^^^^^ attempt to compute `u128::MAX * 5_u128`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:199:15
--> $DIR/lint-overflowing-ops.rs:202:15
|
LL | let _n = &(u64::MAX * 5);
| ^^^^^^^^^^^^^^ attempt to compute `u64::MAX * 5_u64`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:196:15
--> $DIR/lint-overflowing-ops.rs:199:15
|
LL | let _n = &(u32::MAX * 5);
| ^^^^^^^^^^^^^^ attempt to compute `u32::MAX * 5_u32`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:193:15
--> $DIR/lint-overflowing-ops.rs:196:15
|
LL | let _n = &(u16::MAX * 5);
| ^^^^^^^^^^^^^^ attempt to compute `u16::MAX * 5_u16`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:190:15
--> $DIR/lint-overflowing-ops.rs:193:15
|
LL | let _n = &(u8::MAX * 5);
| ^^^^^^^^^^^^^ attempt to compute `u8::MAX * 5_u8`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:188:15
|
LL | let _n = &(-i8::MIN);
| ^^^^^^^^^^ attempt to negate `i8::MIN`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:185:15
|
@@ -701,82 +701,82 @@ LL | let _n = 1usize - 5;
| ^^^^^^^^^^ attempt to compute `1_usize - 5_usize`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:189:14
--> $DIR/lint-overflowing-ops.rs:187:14
|
LL | let _n = -i8::MIN;
| ^^^^^^^^ attempt to negate `i8::MIN`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:192:14
|
LL | let _n = u8::MAX * 5;
| ^^^^^^^^^^^ attempt to compute `u8::MAX * 5_u8`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:192:14
--> $DIR/lint-overflowing-ops.rs:195:14
|
LL | let _n = u16::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `u16::MAX * 5_u16`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:195:14
--> $DIR/lint-overflowing-ops.rs:198:14
|
LL | let _n = u32::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `u32::MAX * 5_u32`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:198:14
--> $DIR/lint-overflowing-ops.rs:201:14
|
LL | let _n = u64::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `u64::MAX * 5_u64`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:201:14
--> $DIR/lint-overflowing-ops.rs:204:14
|
LL | let _n = u128::MAX * 5;
| ^^^^^^^^^^^^^ attempt to compute `u128::MAX * 5_u128`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:204:14
|
LL | let _n = i8::MAX * i8::MAX;
| ^^^^^^^^^^^^^^^^^ attempt to compute `i8::MAX * i8::MAX`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:207:14
|
LL | let _n = i16::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `i16::MAX * 5_i16`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:210:14
|
LL | let _n = i32::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `i32::MAX * 5_i32`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:213:14
|
LL | let _n = i64::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `i64::MAX * 5_i64`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:216:14
|
LL | let _n = i128::MAX * 5;
| ^^^^^^^^^^^^^ attempt to compute `i128::MAX * 5_i128`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:219:14
|
LL | let _n = isize::MAX * 5;
| ^^^^^^^^^^^^^^ attempt to compute `isize::MAX * 5_isize`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:222:14
|
LL | let _n = usize::MAX * 5;
| ^^^^^^^^^^^^^^ attempt to compute `usize::MAX * 5_usize`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:210:14
|
LL | let _n = i8::MAX * i8::MAX;
| ^^^^^^^^^^^^^^^^^ attempt to compute `i8::MAX * i8::MAX`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:213:14
|
LL | let _n = i16::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `i16::MAX * 5_i16`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:216:14
|
LL | let _n = i32::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `i32::MAX * 5_i32`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:219:14
|
LL | let _n = i64::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `i64::MAX * 5_i64`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:222:14
|
LL | let _n = i128::MAX * 5;
| ^^^^^^^^^^^^^ attempt to compute `i128::MAX * 5_i128`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:225:14
|
LL | let _n = -i8::MIN;
| ^^^^^^^^ attempt to negate `i8::MIN`, which would overflow
LL | let _n = isize::MAX * 5;
| ^^^^^^^^^^^^^^ attempt to compute `isize::MAX * 5_isize`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:230:14
@@ -843,219 +843,291 @@ LL | let _n = &(1u128 / 0);
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:245:14
|
LL | let _n = 1i8 / 0;
| ^^^^^^^ attempt to divide `1_i8` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:246:15
|
LL | let _n = &(1i8 / 0);
| ^^^^^^^^^ attempt to divide `1_i8` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:248:14
|
LL | let _n = 1i16 / 0;
| ^^^^^^^^ attempt to divide `1_i16` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:249:15
|
LL | let _n = &(1i16 / 0);
| ^^^^^^^^^^ attempt to divide `1_i16` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:251:14
|
LL | let _n = 1i32 / 0;
| ^^^^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:252:15
|
LL | let _n = &(1i32 / 0);
| ^^^^^^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:254:14
|
LL | let _n = 1i64 / 0;
| ^^^^^^^^ attempt to divide `1_i64` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:255:15
|
LL | let _n = &(1i64 / 0);
| ^^^^^^^^^^ attempt to divide `1_i64` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:257:14
|
LL | let _n = 1i128 / 0;
| ^^^^^^^^^ attempt to divide `1_i128` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:258:15
|
LL | let _n = &(1i128 / 0);
| ^^^^^^^^^^^ attempt to divide `1_i128` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:260:14
|
LL | let _n = 1isize / 0;
| ^^^^^^^^^^ attempt to divide `1_isize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:261:15
|
LL | let _n = &(1isize / 0);
| ^^^^^^^^^^^^ attempt to divide `1_isize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:263:14
|
LL | let _n = 1usize / 0;
| ^^^^^^^^^^ attempt to divide `1_usize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:264:15
--> $DIR/lint-overflowing-ops.rs:246:15
|
LL | let _n = &(1usize / 0);
| ^^^^^^^^^^^^ attempt to divide `1_usize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:248:14
|
LL | let _n = 1i8 / 0;
| ^^^^^^^ attempt to divide `1_i8` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:249:15
|
LL | let _n = &(1i8 / 0);
| ^^^^^^^^^ attempt to divide `1_i8` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:250:14
|
LL | let _n = i8::MIN / -1;
| ^^^^^^^^^^^^ attempt to compute `i8::MIN / -1_i8`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:251:15
|
LL | let _n = &(i8::MIN / -1);
| ^^^^^^^^^^^^^^ attempt to compute `i8::MIN / -1_i8`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:251:15
|
LL | let _n = &(i8::MIN / -1);
| ^^^^^^^^^^^^^^ overflow in signed division (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:251:14
|
LL | let _n = &(i8::MIN / -1);
| ^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:254:14
|
LL | let _n = 1i16 / 0;
| ^^^^^^^^ attempt to divide `1_i16` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:255:15
|
LL | let _n = &(1i16 / 0);
| ^^^^^^^^^^ attempt to divide `1_i16` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:256:14
|
LL | let _n = i16::MIN / -1;
| ^^^^^^^^^^^^^ attempt to compute `i16::MIN / -1_i16`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:257:15
|
LL | let _n = &(i16::MIN / -1);
| ^^^^^^^^^^^^^^^ attempt to compute `i16::MIN / -1_i16`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:257:15
|
LL | let _n = &(i16::MIN / -1);
| ^^^^^^^^^^^^^^^ overflow in signed division (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:257:14
|
LL | let _n = &(i16::MIN / -1);
| ^^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:260:14
|
LL | let _n = 1i32 / 0;
| ^^^^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:261:15
|
LL | let _n = &(1i32 / 0);
| ^^^^^^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:262:14
|
LL | let _n = i32::MIN / -1;
| ^^^^^^^^^^^^^ attempt to compute `i32::MIN / -1_i32`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:263:15
|
LL | let _n = &(i32::MIN / -1);
| ^^^^^^^^^^^^^^^ attempt to compute `i32::MIN / -1_i32`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:263:15
|
LL | let _n = &(i32::MIN / -1);
| ^^^^^^^^^^^^^^^ overflow in signed division (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:263:14
|
LL | let _n = &(i32::MIN / -1);
| ^^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:266:14
|
LL | let _n = 1i64 / 0;
| ^^^^^^^^ attempt to divide `1_i64` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:267:15
|
LL | let _n = &(1i64 / 0);
| ^^^^^^^^^^ attempt to divide `1_i64` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:268:14
|
LL | let _n = i64::MIN / -1;
| ^^^^^^^^^^^^^ attempt to compute `i64::MIN / -1_i64`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:269:15
|
LL | let _n = &(i64::MIN / -1);
| ^^^^^^^^^^^^^^^ attempt to compute `i64::MIN / -1_i64`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:269:15
|
LL | let _n = &(i64::MIN / -1);
| ^^^^^^^^^^^^^^^ overflow in signed division (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:269:14
|
LL | let _n = &(i64::MIN / -1);
| ^^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:272:14
|
LL | let _n = 1i128 / 0;
| ^^^^^^^^^ attempt to divide `1_i128` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:273:15
|
LL | let _n = &(1i128 / 0);
| ^^^^^^^^^^^ attempt to divide `1_i128` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:274:14
|
LL | let _n = i128::MIN / -1;
| ^^^^^^^^^^^^^^ attempt to compute `i128::MIN / -1_i128`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:275:15
|
LL | let _n = &(i128::MIN / -1);
| ^^^^^^^^^^^^^^^^ attempt to compute `i128::MIN / -1_i128`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:275:15
|
LL | let _n = &(i128::MIN / -1);
| ^^^^^^^^^^^^^^^^ overflow in signed division (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:275:14
|
LL | let _n = &(i128::MIN / -1);
| ^^^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:278:14
|
LL | let _n = 1isize / 0;
| ^^^^^^^^^^ attempt to divide `1_isize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:279:15
|
LL | let _n = &(1isize / 0);
| ^^^^^^^^^^^^ attempt to divide `1_isize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:280:14
|
LL | let _n = isize::MIN / -1;
| ^^^^^^^^^^^^^^^ attempt to compute `isize::MIN / -1_isize`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:281:15
|
LL | let _n = &(isize::MIN / -1);
| ^^^^^^^^^^^^^^^^^ attempt to compute `isize::MIN / -1_isize`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:281:15
|
LL | let _n = &(isize::MIN / -1);
| ^^^^^^^^^^^^^^^^^ overflow in signed division (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:281:14
|
LL | let _n = &(isize::MIN / -1);
| ^^^^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:286:14
|
LL | let _n = 1u8 % 0;
| ^^^^^^^ attempt to calculate the remainder of `1_u8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:269:15
--> $DIR/lint-overflowing-ops.rs:287:15
|
LL | let _n = &(1u8 % 0);
| ^^^^^^^^^ attempt to calculate the remainder of `1_u8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:271:14
--> $DIR/lint-overflowing-ops.rs:289:14
|
LL | let _n = 1u16 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_u16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:272:15
--> $DIR/lint-overflowing-ops.rs:290:15
|
LL | let _n = &(1u16 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_u16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:274:14
--> $DIR/lint-overflowing-ops.rs:292:14
|
LL | let _n = 1u32 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_u32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:275:15
--> $DIR/lint-overflowing-ops.rs:293:15
|
LL | let _n = &(1u32 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_u32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:277:14
--> $DIR/lint-overflowing-ops.rs:295:14
|
LL | let _n = 1u64 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_u64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:278:15
--> $DIR/lint-overflowing-ops.rs:296:15
|
LL | let _n = &(1u64 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_u64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:280:14
--> $DIR/lint-overflowing-ops.rs:298:14
|
LL | let _n = 1u128 % 0;
| ^^^^^^^^^ attempt to calculate the remainder of `1_u128` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:281:15
--> $DIR/lint-overflowing-ops.rs:299:15
|
LL | let _n = &(1u128 % 0);
| ^^^^^^^^^^^ attempt to calculate the remainder of `1_u128` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:283:14
|
LL | let _n = 1i8 % 0;
| ^^^^^^^ attempt to calculate the remainder of `1_i8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:284:15
|
LL | let _n = &(1i8 % 0);
| ^^^^^^^^^ attempt to calculate the remainder of `1_i8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:286:14
|
LL | let _n = 1i16 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_i16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:287:15
|
LL | let _n = &(1i16 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_i16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:289:14
|
LL | let _n = 1i32 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_i32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:290:15
|
LL | let _n = &(1i32 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_i32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:292:14
|
LL | let _n = 1i64 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_i64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:293:15
|
LL | let _n = &(1i64 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_i64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:295:14
|
LL | let _n = 1i128 % 0;
| ^^^^^^^^^ attempt to calculate the remainder of `1_i128` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:296:15
|
LL | let _n = &(1i128 % 0);
| ^^^^^^^^^^^ attempt to calculate the remainder of `1_i128` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:298:14
|
LL | let _n = 1isize % 0;
| ^^^^^^^^^^ attempt to calculate the remainder of `1_isize` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:299:15
|
LL | let _n = &(1isize % 0);
| ^^^^^^^^^^^^ attempt to calculate the remainder of `1_isize` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:301:14
|
@@ -1068,161 +1140,234 @@ error: this operation will panic at runtime
LL | let _n = &(1usize % 0);
| ^^^^^^^^^^^^ attempt to calculate the remainder of `1_usize` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:304:14
|
LL | let _n = 1i8 % 0;
| ^^^^^^^ attempt to calculate the remainder of `1_i8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:305:15
|
LL | let _n = &(1i8 % 0);
| ^^^^^^^^^ attempt to calculate the remainder of `1_i8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:306:14
|
LL | let _n = i8::MIN % -1;
| ^^^^^^^^^^^^ attempt to compute `i8::MIN % -1_i8`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:307:15
|
LL | let _n = &(i8::MIN % -1);
| ^^^^^^^^^^^^^^ attempt to compute `i8::MIN % -1_i8`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:307:15
|
LL | let _n = &(i8::MIN % -1);
| ^^^^^^^^^^^^^^ overflow in signed remainder (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:307:14
|
LL | let _n = &(i8::MIN % -1);
| ^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:310:14
|
LL | let _n = 1i16 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_i16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:311:15
|
LL | let _n = &(1i16 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_i16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:312:14
|
LL | let _n = i16::MIN % -1;
| ^^^^^^^^^^^^^ attempt to compute `i16::MIN % -1_i16`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:313:15
|
LL | let _n = &(i16::MIN % -1);
| ^^^^^^^^^^^^^^^ attempt to compute `i16::MIN % -1_i16`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:313:15
|
LL | let _n = &(i16::MIN % -1);
| ^^^^^^^^^^^^^^^ overflow in signed remainder (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:313:14
|
LL | let _n = &(i16::MIN % -1);
| ^^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:316:14
|
LL | let _n = 1i32 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_i32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:317:15
|
LL | let _n = &(1i32 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_i32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:318:14
|
LL | let _n = i32::MIN % -1;
| ^^^^^^^^^^^^^ attempt to compute `i32::MIN % -1_i32`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:319:15
|
LL | let _n = &(i32::MIN % -1);
| ^^^^^^^^^^^^^^^ attempt to compute `i32::MIN % -1_i32`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:319:15
|
LL | let _n = &(i32::MIN % -1);
| ^^^^^^^^^^^^^^^ overflow in signed remainder (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:319:14
|
LL | let _n = &(i32::MIN % -1);
| ^^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:322:14
|
LL | let _n = 1i64 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_i64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:323:15
|
LL | let _n = &(1i64 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_i64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:324:14
|
LL | let _n = i64::MIN % -1;
| ^^^^^^^^^^^^^ attempt to compute `i64::MIN % -1_i64`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:325:15
|
LL | let _n = &(i64::MIN % -1);
| ^^^^^^^^^^^^^^^ attempt to compute `i64::MIN % -1_i64`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:325:15
|
LL | let _n = &(i64::MIN % -1);
| ^^^^^^^^^^^^^^^ overflow in signed remainder (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:325:14
|
LL | let _n = &(i64::MIN % -1);
| ^^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:328:14
|
LL | let _n = 1i128 % 0;
| ^^^^^^^^^ attempt to calculate the remainder of `1_i128` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:329:15
|
LL | let _n = &(1i128 % 0);
| ^^^^^^^^^^^ attempt to calculate the remainder of `1_i128` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:330:14
|
LL | let _n = i128::MIN % -1;
| ^^^^^^^^^^^^^^ attempt to compute `i128::MIN % -1_i128`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:331:15
|
LL | let _n = &(i128::MIN % -1);
| ^^^^^^^^^^^^^^^^ attempt to compute `i128::MIN % -1_i128`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:331:15
|
LL | let _n = &(i128::MIN % -1);
| ^^^^^^^^^^^^^^^^ overflow in signed remainder (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:331:14
|
LL | let _n = &(i128::MIN % -1);
| ^^^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:334:14
|
LL | let _n = 1isize % 0;
| ^^^^^^^^^^ attempt to calculate the remainder of `1_isize` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:335:15
|
LL | let _n = &(1isize % 0);
| ^^^^^^^^^^^^ attempt to calculate the remainder of `1_isize` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:336:14
|
LL | let _n = isize::MIN % -1;
| ^^^^^^^^^^^^^^^ attempt to compute `isize::MIN % -1_isize`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:337:15
|
LL | let _n = &(isize::MIN % -1);
| ^^^^^^^^^^^^^^^^^ attempt to compute `isize::MIN % -1_isize`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:337:15
|
LL | let _n = &(isize::MIN % -1);
| ^^^^^^^^^^^^^^^^^ overflow in signed remainder (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:337:14
|
LL | let _n = &(isize::MIN % -1);
| ^^^^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:341:14
|
LL | let _n = [1, 2, 3][4];
| ^^^^^^^^^^^^ index out of bounds: the length is 3 but the index is 4
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:307:15
--> $DIR/lint-overflowing-ops.rs:342:15
|
LL | let _n = &([1, 2, 3][4]);
| ^^^^^^^^^^^^^^ index out of bounds: the length is 3 but the index is 4
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:311:36
|
LL | assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^^ attempt to compute `isize::MIN / -1_isize`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:313:36
|
LL | assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^ attempt to compute `i8::MIN / -1_i8`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:315:36
|
LL | assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i16::MIN / -1_i16`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:317:36
|
LL | assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i32::MIN / -1_i32`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:319:36
|
LL | assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i64::MIN / -1_i64`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:321:36
|
LL | assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^ attempt to compute `i128::MIN / -1_i128`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:323:36
|
LL | assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
| ^^^^^^^^^^ attempt to divide `1_isize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:325:36
|
LL | assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
| ^^^^^^^ attempt to divide `1_i8` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:327:36
|
LL | assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide `1_i16` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:329:36
|
LL | assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:331:36
|
LL | assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide `1_i64` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:333:36
|
LL | assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
| ^^^^^^^^^ attempt to divide `1_i128` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:335:36
|
LL | assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^^ attempt to compute `isize::MIN % -1_isize`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:337:36
|
LL | assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^ attempt to compute `i8::MIN % -1_i8`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:339:36
|
LL | assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i16::MIN % -1_i16`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:341:36
|
LL | assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i32::MIN % -1_i32`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:343:36
|
LL | assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i64::MIN % -1_i64`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:345:36
|
LL | assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^ attempt to compute `i128::MIN % -1_i128`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:347:36
|
LL | assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
| ^^^^^^^^^^ attempt to calculate the remainder of `1_isize` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:349:36
|
LL | assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
| ^^^^^^^ attempt to calculate the remainder of `1_i8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:351:36
|
LL | assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder of `1_i16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:353:36
|
LL | assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder of `1_i32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:355:36
|
LL | assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder of `1_i64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:357:36
|
LL | assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
| ^^^^^^^^^ attempt to calculate the remainder of `1_i128` with a divisor of zero
error: aborting due to 203 previous errors
error: aborting due to 215 previous errors
For more information about this error, try `rustc --explain E0080`.
tests/ui/lint/lint-overflowing-ops.opt.stderr
+606 -365
View File
@@ -13,81 +13,81 @@ LL | #![deny(arithmetic_overflow)]
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:226:15
|
LL | let _n = &(-i8::MIN);
| ^^^^^^^^^^ attempt to negate `i8::MIN`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:223:15
|
LL | let _n = &(usize::MAX * 5);
| ^^^^^^^^^^^^^^^^ attempt to compute `usize::MAX * 5_usize`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:220:15
|
LL | let _n = &(isize::MAX * 5);
| ^^^^^^^^^^^^^^^^ attempt to compute `isize::MAX * 5_isize`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:217:15
--> $DIR/lint-overflowing-ops.rs:223:15
|
LL | let _n = &(i128::MAX * 5);
| ^^^^^^^^^^^^^^^ attempt to compute `i128::MAX * 5_i128`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:214:15
--> $DIR/lint-overflowing-ops.rs:220:15
|
LL | let _n = &(i64::MAX * 5);
| ^^^^^^^^^^^^^^ attempt to compute `i64::MAX * 5_i64`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:211:15
--> $DIR/lint-overflowing-ops.rs:217:15
|
LL | let _n = &(i32::MAX * 5);
| ^^^^^^^^^^^^^^ attempt to compute `i32::MAX * 5_i32`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:208:15
--> $DIR/lint-overflowing-ops.rs:214:15
|
LL | let _n = &(i16::MAX * 5);
| ^^^^^^^^^^^^^^ attempt to compute `i16::MAX * 5_i16`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:205:15
--> $DIR/lint-overflowing-ops.rs:211:15
|
LL | let _n = &(i8::MAX * i8::MAX);
| ^^^^^^^^^^^^^^^^^^^ attempt to compute `i8::MAX * i8::MAX`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:202:15
--> $DIR/lint-overflowing-ops.rs:208:15
|
LL | let _n = &(usize::MAX * 5);
| ^^^^^^^^^^^^^^^^ attempt to compute `usize::MAX * 5_usize`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:205:15
|
LL | let _n = &(u128::MAX * 5);
| ^^^^^^^^^^^^^^^ attempt to compute `u128::MAX * 5_u128`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:199:15
--> $DIR/lint-overflowing-ops.rs:202:15
|
LL | let _n = &(u64::MAX * 5);
| ^^^^^^^^^^^^^^ attempt to compute `u64::MAX * 5_u64`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:196:15
--> $DIR/lint-overflowing-ops.rs:199:15
|
LL | let _n = &(u32::MAX * 5);
| ^^^^^^^^^^^^^^ attempt to compute `u32::MAX * 5_u32`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:193:15
--> $DIR/lint-overflowing-ops.rs:196:15
|
LL | let _n = &(u16::MAX * 5);
| ^^^^^^^^^^^^^^ attempt to compute `u16::MAX * 5_u16`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:190:15
--> $DIR/lint-overflowing-ops.rs:193:15
|
LL | let _n = &(u8::MAX * 5);
| ^^^^^^^^^^^^^ attempt to compute `u8::MAX * 5_u8`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:188:15
|
LL | let _n = &(-i8::MIN);
| ^^^^^^^^^^ attempt to negate `i8::MIN`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:185:15
|
@@ -701,82 +701,82 @@ LL | let _n = 1usize - 5;
| ^^^^^^^^^^ attempt to compute `1_usize - 5_usize`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:189:14
--> $DIR/lint-overflowing-ops.rs:187:14
|
LL | let _n = -i8::MIN;
| ^^^^^^^^ attempt to negate `i8::MIN`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:192:14
|
LL | let _n = u8::MAX * 5;
| ^^^^^^^^^^^ attempt to compute `u8::MAX * 5_u8`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:192:14
--> $DIR/lint-overflowing-ops.rs:195:14
|
LL | let _n = u16::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `u16::MAX * 5_u16`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:195:14
--> $DIR/lint-overflowing-ops.rs:198:14
|
LL | let _n = u32::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `u32::MAX * 5_u32`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:198:14
--> $DIR/lint-overflowing-ops.rs:201:14
|
LL | let _n = u64::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `u64::MAX * 5_u64`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:201:14
--> $DIR/lint-overflowing-ops.rs:204:14
|
LL | let _n = u128::MAX * 5;
| ^^^^^^^^^^^^^ attempt to compute `u128::MAX * 5_u128`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:204:14
|
LL | let _n = i8::MAX * i8::MAX;
| ^^^^^^^^^^^^^^^^^ attempt to compute `i8::MAX * i8::MAX`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:207:14
|
LL | let _n = i16::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `i16::MAX * 5_i16`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:210:14
|
LL | let _n = i32::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `i32::MAX * 5_i32`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:213:14
|
LL | let _n = i64::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `i64::MAX * 5_i64`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:216:14
|
LL | let _n = i128::MAX * 5;
| ^^^^^^^^^^^^^ attempt to compute `i128::MAX * 5_i128`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:219:14
|
LL | let _n = isize::MAX * 5;
| ^^^^^^^^^^^^^^ attempt to compute `isize::MAX * 5_isize`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:222:14
|
LL | let _n = usize::MAX * 5;
| ^^^^^^^^^^^^^^ attempt to compute `usize::MAX * 5_usize`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:210:14
|
LL | let _n = i8::MAX * i8::MAX;
| ^^^^^^^^^^^^^^^^^ attempt to compute `i8::MAX * i8::MAX`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:213:14
|
LL | let _n = i16::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `i16::MAX * 5_i16`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:216:14
|
LL | let _n = i32::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `i32::MAX * 5_i32`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:219:14
|
LL | let _n = i64::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `i64::MAX * 5_i64`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:222:14
|
LL | let _n = i128::MAX * 5;
| ^^^^^^^^^^^^^ attempt to compute `i128::MAX * 5_i128`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:225:14
|
LL | let _n = -i8::MIN;
| ^^^^^^^^ attempt to negate `i8::MIN`, which would overflow
LL | let _n = isize::MAX * 5;
| ^^^^^^^^^^^^^^ attempt to compute `isize::MAX * 5_isize`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:230:14
@@ -843,219 +843,339 @@ LL | let _n = &(1u128 / 0);
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:245:14
|
LL | let _n = 1i8 / 0;
| ^^^^^^^ attempt to divide `1_i8` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:246:15
|
LL | let _n = &(1i8 / 0);
| ^^^^^^^^^ attempt to divide `1_i8` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:248:14
|
LL | let _n = 1i16 / 0;
| ^^^^^^^^ attempt to divide `1_i16` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:249:15
|
LL | let _n = &(1i16 / 0);
| ^^^^^^^^^^ attempt to divide `1_i16` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:251:14
|
LL | let _n = 1i32 / 0;
| ^^^^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:252:15
|
LL | let _n = &(1i32 / 0);
| ^^^^^^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:254:14
|
LL | let _n = 1i64 / 0;
| ^^^^^^^^ attempt to divide `1_i64` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:255:15
|
LL | let _n = &(1i64 / 0);
| ^^^^^^^^^^ attempt to divide `1_i64` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:257:14
|
LL | let _n = 1i128 / 0;
| ^^^^^^^^^ attempt to divide `1_i128` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:258:15
|
LL | let _n = &(1i128 / 0);
| ^^^^^^^^^^^ attempt to divide `1_i128` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:260:14
|
LL | let _n = 1isize / 0;
| ^^^^^^^^^^ attempt to divide `1_isize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:261:15
|
LL | let _n = &(1isize / 0);
| ^^^^^^^^^^^^ attempt to divide `1_isize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:263:14
|
LL | let _n = 1usize / 0;
| ^^^^^^^^^^ attempt to divide `1_usize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:264:15
--> $DIR/lint-overflowing-ops.rs:246:15
|
LL | let _n = &(1usize / 0);
| ^^^^^^^^^^^^ attempt to divide `1_usize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:248:14
|
LL | let _n = 1i8 / 0;
| ^^^^^^^ attempt to divide `1_i8` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:249:15
|
LL | let _n = &(1i8 / 0);
| ^^^^^^^^^ attempt to divide `1_i8` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:250:14
|
LL | let _n = i8::MIN / -1;
| ^^^^^^^^^^^^ attempt to compute `i8::MIN / -1_i8`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:251:15
|
LL | let _n = &(i8::MIN / -1);
| ^^^^^^^^^^^^^^ attempt to compute `i8::MIN / -1_i8`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:251:15
|
LL | let _n = &(i8::MIN / -1);
| ^^^^^^^^^^^^^^ overflow in signed division (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:251:14
|
LL | let _n = &(i8::MIN / -1);
| ^^^^^^^^^^^^^^^
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:251:14
|
LL | let _n = &(i8::MIN / -1);
| ^^^^^^^^^^^^^^^
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:254:14
|
LL | let _n = 1i16 / 0;
| ^^^^^^^^ attempt to divide `1_i16` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:255:15
|
LL | let _n = &(1i16 / 0);
| ^^^^^^^^^^ attempt to divide `1_i16` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:256:14
|
LL | let _n = i16::MIN / -1;
| ^^^^^^^^^^^^^ attempt to compute `i16::MIN / -1_i16`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:257:15
|
LL | let _n = &(i16::MIN / -1);
| ^^^^^^^^^^^^^^^ attempt to compute `i16::MIN / -1_i16`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:257:15
|
LL | let _n = &(i16::MIN / -1);
| ^^^^^^^^^^^^^^^ overflow in signed division (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:257:14
|
LL | let _n = &(i16::MIN / -1);
| ^^^^^^^^^^^^^^^^
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:257:14
|
LL | let _n = &(i16::MIN / -1);
| ^^^^^^^^^^^^^^^^
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:260:14
|
LL | let _n = 1i32 / 0;
| ^^^^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:261:15
|
LL | let _n = &(1i32 / 0);
| ^^^^^^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:262:14
|
LL | let _n = i32::MIN / -1;
| ^^^^^^^^^^^^^ attempt to compute `i32::MIN / -1_i32`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:263:15
|
LL | let _n = &(i32::MIN / -1);
| ^^^^^^^^^^^^^^^ attempt to compute `i32::MIN / -1_i32`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:263:15
|
LL | let _n = &(i32::MIN / -1);
| ^^^^^^^^^^^^^^^ overflow in signed division (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:263:14
|
LL | let _n = &(i32::MIN / -1);
| ^^^^^^^^^^^^^^^^
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:263:14
|
LL | let _n = &(i32::MIN / -1);
| ^^^^^^^^^^^^^^^^
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:266:14
|
LL | let _n = 1i64 / 0;
| ^^^^^^^^ attempt to divide `1_i64` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:267:15
|
LL | let _n = &(1i64 / 0);
| ^^^^^^^^^^ attempt to divide `1_i64` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:268:14
|
LL | let _n = i64::MIN / -1;
| ^^^^^^^^^^^^^ attempt to compute `i64::MIN / -1_i64`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:269:15
|
LL | let _n = &(i64::MIN / -1);
| ^^^^^^^^^^^^^^^ attempt to compute `i64::MIN / -1_i64`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:269:15
|
LL | let _n = &(i64::MIN / -1);
| ^^^^^^^^^^^^^^^ overflow in signed division (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:269:14
|
LL | let _n = &(i64::MIN / -1);
| ^^^^^^^^^^^^^^^^
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:269:14
|
LL | let _n = &(i64::MIN / -1);
| ^^^^^^^^^^^^^^^^
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:272:14
|
LL | let _n = 1i128 / 0;
| ^^^^^^^^^ attempt to divide `1_i128` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:273:15
|
LL | let _n = &(1i128 / 0);
| ^^^^^^^^^^^ attempt to divide `1_i128` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:274:14
|
LL | let _n = i128::MIN / -1;
| ^^^^^^^^^^^^^^ attempt to compute `i128::MIN / -1_i128`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:275:15
|
LL | let _n = &(i128::MIN / -1);
| ^^^^^^^^^^^^^^^^ attempt to compute `i128::MIN / -1_i128`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:275:15
|
LL | let _n = &(i128::MIN / -1);
| ^^^^^^^^^^^^^^^^ overflow in signed division (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:275:14
|
LL | let _n = &(i128::MIN / -1);
| ^^^^^^^^^^^^^^^^^
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:275:14
|
LL | let _n = &(i128::MIN / -1);
| ^^^^^^^^^^^^^^^^^
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:278:14
|
LL | let _n = 1isize / 0;
| ^^^^^^^^^^ attempt to divide `1_isize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:279:15
|
LL | let _n = &(1isize / 0);
| ^^^^^^^^^^^^ attempt to divide `1_isize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:280:14
|
LL | let _n = isize::MIN / -1;
| ^^^^^^^^^^^^^^^ attempt to compute `isize::MIN / -1_isize`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:281:15
|
LL | let _n = &(isize::MIN / -1);
| ^^^^^^^^^^^^^^^^^ attempt to compute `isize::MIN / -1_isize`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:281:15
|
LL | let _n = &(isize::MIN / -1);
| ^^^^^^^^^^^^^^^^^ overflow in signed division (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:281:14
|
LL | let _n = &(isize::MIN / -1);
| ^^^^^^^^^^^^^^^^^^
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:281:14
|
LL | let _n = &(isize::MIN / -1);
| ^^^^^^^^^^^^^^^^^^
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:286:14
|
LL | let _n = 1u8 % 0;
| ^^^^^^^ attempt to calculate the remainder of `1_u8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:269:15
--> $DIR/lint-overflowing-ops.rs:287:15
|
LL | let _n = &(1u8 % 0);
| ^^^^^^^^^ attempt to calculate the remainder of `1_u8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:271:14
--> $DIR/lint-overflowing-ops.rs:289:14
|
LL | let _n = 1u16 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_u16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:272:15
--> $DIR/lint-overflowing-ops.rs:290:15
|
LL | let _n = &(1u16 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_u16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:274:14
--> $DIR/lint-overflowing-ops.rs:292:14
|
LL | let _n = 1u32 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_u32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:275:15
--> $DIR/lint-overflowing-ops.rs:293:15
|
LL | let _n = &(1u32 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_u32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:277:14
--> $DIR/lint-overflowing-ops.rs:295:14
|
LL | let _n = 1u64 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_u64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:278:15
--> $DIR/lint-overflowing-ops.rs:296:15
|
LL | let _n = &(1u64 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_u64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:280:14
--> $DIR/lint-overflowing-ops.rs:298:14
|
LL | let _n = 1u128 % 0;
| ^^^^^^^^^ attempt to calculate the remainder of `1_u128` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:281:15
--> $DIR/lint-overflowing-ops.rs:299:15
|
LL | let _n = &(1u128 % 0);
| ^^^^^^^^^^^ attempt to calculate the remainder of `1_u128` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:283:14
|
LL | let _n = 1i8 % 0;
| ^^^^^^^ attempt to calculate the remainder of `1_i8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:284:15
|
LL | let _n = &(1i8 % 0);
| ^^^^^^^^^ attempt to calculate the remainder of `1_i8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:286:14
|
LL | let _n = 1i16 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_i16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:287:15
|
LL | let _n = &(1i16 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_i16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:289:14
|
LL | let _n = 1i32 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_i32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:290:15
|
LL | let _n = &(1i32 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_i32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:292:14
|
LL | let _n = 1i64 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_i64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:293:15
|
LL | let _n = &(1i64 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_i64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:295:14
|
LL | let _n = 1i128 % 0;
| ^^^^^^^^^ attempt to calculate the remainder of `1_i128` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:296:15
|
LL | let _n = &(1i128 % 0);
| ^^^^^^^^^^^ attempt to calculate the remainder of `1_i128` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:298:14
|
LL | let _n = 1isize % 0;
| ^^^^^^^^^^ attempt to calculate the remainder of `1_isize` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:299:15
|
LL | let _n = &(1isize % 0);
| ^^^^^^^^^^^^ attempt to calculate the remainder of `1_isize` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:301:14
|
@@ -1068,161 +1188,282 @@ error: this operation will panic at runtime
LL | let _n = &(1usize % 0);
| ^^^^^^^^^^^^ attempt to calculate the remainder of `1_usize` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:304:14
|
LL | let _n = 1i8 % 0;
| ^^^^^^^ attempt to calculate the remainder of `1_i8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:305:15
|
LL | let _n = &(1i8 % 0);
| ^^^^^^^^^ attempt to calculate the remainder of `1_i8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:306:14
|
LL | let _n = i8::MIN % -1;
| ^^^^^^^^^^^^ attempt to compute `i8::MIN % -1_i8`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:307:15
|
LL | let _n = &(i8::MIN % -1);
| ^^^^^^^^^^^^^^ attempt to compute `i8::MIN % -1_i8`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:307:15
|
LL | let _n = &(i8::MIN % -1);
| ^^^^^^^^^^^^^^ overflow in signed remainder (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:307:14
|
LL | let _n = &(i8::MIN % -1);
| ^^^^^^^^^^^^^^^
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:307:14
|
LL | let _n = &(i8::MIN % -1);
| ^^^^^^^^^^^^^^^
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:310:14
|
LL | let _n = 1i16 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_i16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:311:15
|
LL | let _n = &(1i16 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_i16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:312:14
|
LL | let _n = i16::MIN % -1;
| ^^^^^^^^^^^^^ attempt to compute `i16::MIN % -1_i16`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:313:15
|
LL | let _n = &(i16::MIN % -1);
| ^^^^^^^^^^^^^^^ attempt to compute `i16::MIN % -1_i16`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:313:15
|
LL | let _n = &(i16::MIN % -1);
| ^^^^^^^^^^^^^^^ overflow in signed remainder (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:313:14
|
LL | let _n = &(i16::MIN % -1);
| ^^^^^^^^^^^^^^^^
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:313:14
|
LL | let _n = &(i16::MIN % -1);
| ^^^^^^^^^^^^^^^^
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:316:14
|
LL | let _n = 1i32 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_i32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:317:15
|
LL | let _n = &(1i32 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_i32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:318:14
|
LL | let _n = i32::MIN % -1;
| ^^^^^^^^^^^^^ attempt to compute `i32::MIN % -1_i32`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:319:15
|
LL | let _n = &(i32::MIN % -1);
| ^^^^^^^^^^^^^^^ attempt to compute `i32::MIN % -1_i32`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:319:15
|
LL | let _n = &(i32::MIN % -1);
| ^^^^^^^^^^^^^^^ overflow in signed remainder (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:319:14
|
LL | let _n = &(i32::MIN % -1);
| ^^^^^^^^^^^^^^^^
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:319:14
|
LL | let _n = &(i32::MIN % -1);
| ^^^^^^^^^^^^^^^^
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:322:14
|
LL | let _n = 1i64 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_i64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:323:15
|
LL | let _n = &(1i64 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_i64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:324:14
|
LL | let _n = i64::MIN % -1;
| ^^^^^^^^^^^^^ attempt to compute `i64::MIN % -1_i64`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:325:15
|
LL | let _n = &(i64::MIN % -1);
| ^^^^^^^^^^^^^^^ attempt to compute `i64::MIN % -1_i64`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:325:15
|
LL | let _n = &(i64::MIN % -1);
| ^^^^^^^^^^^^^^^ overflow in signed remainder (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:325:14
|
LL | let _n = &(i64::MIN % -1);
| ^^^^^^^^^^^^^^^^
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:325:14
|
LL | let _n = &(i64::MIN % -1);
| ^^^^^^^^^^^^^^^^
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:328:14
|
LL | let _n = 1i128 % 0;
| ^^^^^^^^^ attempt to calculate the remainder of `1_i128` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:329:15
|
LL | let _n = &(1i128 % 0);
| ^^^^^^^^^^^ attempt to calculate the remainder of `1_i128` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:330:14
|
LL | let _n = i128::MIN % -1;
| ^^^^^^^^^^^^^^ attempt to compute `i128::MIN % -1_i128`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:331:15
|
LL | let _n = &(i128::MIN % -1);
| ^^^^^^^^^^^^^^^^ attempt to compute `i128::MIN % -1_i128`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:331:15
|
LL | let _n = &(i128::MIN % -1);
| ^^^^^^^^^^^^^^^^ overflow in signed remainder (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:331:14
|
LL | let _n = &(i128::MIN % -1);
| ^^^^^^^^^^^^^^^^^
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:331:14
|
LL | let _n = &(i128::MIN % -1);
| ^^^^^^^^^^^^^^^^^
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:334:14
|
LL | let _n = 1isize % 0;
| ^^^^^^^^^^ attempt to calculate the remainder of `1_isize` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:335:15
|
LL | let _n = &(1isize % 0);
| ^^^^^^^^^^^^ attempt to calculate the remainder of `1_isize` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:336:14
|
LL | let _n = isize::MIN % -1;
| ^^^^^^^^^^^^^^^ attempt to compute `isize::MIN % -1_isize`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:337:15
|
LL | let _n = &(isize::MIN % -1);
| ^^^^^^^^^^^^^^^^^ attempt to compute `isize::MIN % -1_isize`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:337:15
|
LL | let _n = &(isize::MIN % -1);
| ^^^^^^^^^^^^^^^^^ overflow in signed remainder (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:337:14
|
LL | let _n = &(isize::MIN % -1);
| ^^^^^^^^^^^^^^^^^^
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:337:14
|
LL | let _n = &(isize::MIN % -1);
| ^^^^^^^^^^^^^^^^^^
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:341:14
|
LL | let _n = [1, 2, 3][4];
| ^^^^^^^^^^^^ index out of bounds: the length is 3 but the index is 4
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:307:15
--> $DIR/lint-overflowing-ops.rs:342:15
|
LL | let _n = &([1, 2, 3][4]);
| ^^^^^^^^^^^^^^ index out of bounds: the length is 3 but the index is 4
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:311:36
|
LL | assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^^ attempt to compute `isize::MIN / -1_isize`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:313:36
|
LL | assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^ attempt to compute `i8::MIN / -1_i8`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:315:36
|
LL | assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i16::MIN / -1_i16`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:317:36
|
LL | assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i32::MIN / -1_i32`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:319:36
|
LL | assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i64::MIN / -1_i64`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:321:36
|
LL | assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^ attempt to compute `i128::MIN / -1_i128`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:323:36
|
LL | assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
| ^^^^^^^^^^ attempt to divide `1_isize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:325:36
|
LL | assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
| ^^^^^^^ attempt to divide `1_i8` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:327:36
|
LL | assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide `1_i16` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:329:36
|
LL | assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:331:36
|
LL | assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide `1_i64` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:333:36
|
LL | assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
| ^^^^^^^^^ attempt to divide `1_i128` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:335:36
|
LL | assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^^ attempt to compute `isize::MIN % -1_isize`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:337:36
|
LL | assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^ attempt to compute `i8::MIN % -1_i8`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:339:36
|
LL | assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i16::MIN % -1_i16`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:341:36
|
LL | assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i32::MIN % -1_i32`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:343:36
|
LL | assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i64::MIN % -1_i64`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:345:36
|
LL | assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^ attempt to compute `i128::MIN % -1_i128`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:347:36
|
LL | assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
| ^^^^^^^^^^ attempt to calculate the remainder of `1_isize` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:349:36
|
LL | assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
| ^^^^^^^ attempt to calculate the remainder of `1_i8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:351:36
|
LL | assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder of `1_i16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:353:36
|
LL | assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder of `1_i32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:355:36
|
LL | assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder of `1_i64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:357:36
|
LL | assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
| ^^^^^^^^^ attempt to calculate the remainder of `1_i128` with a divisor of zero
error: aborting due to 203 previous errors
error: aborting due to 215 previous errors
For more information about this error, try `rustc --explain E0080`.
tests/ui/lint/lint-overflowing-ops.opt_with_overflow_checks.stderr
+510 -365
View File
@@ -13,81 +13,81 @@ LL | #![deny(arithmetic_overflow)]
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:226:15
|
LL | let _n = &(-i8::MIN);
| ^^^^^^^^^^ attempt to negate `i8::MIN`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:223:15
|
LL | let _n = &(usize::MAX * 5);
| ^^^^^^^^^^^^^^^^ attempt to compute `usize::MAX * 5_usize`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:220:15
|
LL | let _n = &(isize::MAX * 5);
| ^^^^^^^^^^^^^^^^ attempt to compute `isize::MAX * 5_isize`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:217:15
--> $DIR/lint-overflowing-ops.rs:223:15
|
LL | let _n = &(i128::MAX * 5);
| ^^^^^^^^^^^^^^^ attempt to compute `i128::MAX * 5_i128`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:214:15
--> $DIR/lint-overflowing-ops.rs:220:15
|
LL | let _n = &(i64::MAX * 5);
| ^^^^^^^^^^^^^^ attempt to compute `i64::MAX * 5_i64`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:211:15
--> $DIR/lint-overflowing-ops.rs:217:15
|
LL | let _n = &(i32::MAX * 5);
| ^^^^^^^^^^^^^^ attempt to compute `i32::MAX * 5_i32`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:208:15
--> $DIR/lint-overflowing-ops.rs:214:15
|
LL | let _n = &(i16::MAX * 5);
| ^^^^^^^^^^^^^^ attempt to compute `i16::MAX * 5_i16`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:205:15
--> $DIR/lint-overflowing-ops.rs:211:15
|
LL | let _n = &(i8::MAX * i8::MAX);
| ^^^^^^^^^^^^^^^^^^^ attempt to compute `i8::MAX * i8::MAX`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:202:15
--> $DIR/lint-overflowing-ops.rs:208:15
|
LL | let _n = &(usize::MAX * 5);
| ^^^^^^^^^^^^^^^^ attempt to compute `usize::MAX * 5_usize`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:205:15
|
LL | let _n = &(u128::MAX * 5);
| ^^^^^^^^^^^^^^^ attempt to compute `u128::MAX * 5_u128`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:199:15
--> $DIR/lint-overflowing-ops.rs:202:15
|
LL | let _n = &(u64::MAX * 5);
| ^^^^^^^^^^^^^^ attempt to compute `u64::MAX * 5_u64`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:196:15
--> $DIR/lint-overflowing-ops.rs:199:15
|
LL | let _n = &(u32::MAX * 5);
| ^^^^^^^^^^^^^^ attempt to compute `u32::MAX * 5_u32`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:193:15
--> $DIR/lint-overflowing-ops.rs:196:15
|
LL | let _n = &(u16::MAX * 5);
| ^^^^^^^^^^^^^^ attempt to compute `u16::MAX * 5_u16`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:190:15
--> $DIR/lint-overflowing-ops.rs:193:15
|
LL | let _n = &(u8::MAX * 5);
| ^^^^^^^^^^^^^ attempt to compute `u8::MAX * 5_u8`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:188:15
|
LL | let _n = &(-i8::MIN);
| ^^^^^^^^^^ attempt to negate `i8::MIN`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:185:15
|
@@ -701,82 +701,82 @@ LL | let _n = 1usize - 5;
| ^^^^^^^^^^ attempt to compute `1_usize - 5_usize`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:189:14
--> $DIR/lint-overflowing-ops.rs:187:14
|
LL | let _n = -i8::MIN;
| ^^^^^^^^ attempt to negate `i8::MIN`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:192:14
|
LL | let _n = u8::MAX * 5;
| ^^^^^^^^^^^ attempt to compute `u8::MAX * 5_u8`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:192:14
--> $DIR/lint-overflowing-ops.rs:195:14
|
LL | let _n = u16::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `u16::MAX * 5_u16`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:195:14
--> $DIR/lint-overflowing-ops.rs:198:14
|
LL | let _n = u32::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `u32::MAX * 5_u32`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:198:14
--> $DIR/lint-overflowing-ops.rs:201:14
|
LL | let _n = u64::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `u64::MAX * 5_u64`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:201:14
--> $DIR/lint-overflowing-ops.rs:204:14
|
LL | let _n = u128::MAX * 5;
| ^^^^^^^^^^^^^ attempt to compute `u128::MAX * 5_u128`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:204:14
|
LL | let _n = i8::MAX * i8::MAX;
| ^^^^^^^^^^^^^^^^^ attempt to compute `i8::MAX * i8::MAX`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:207:14
|
LL | let _n = i16::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `i16::MAX * 5_i16`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:210:14
|
LL | let _n = i32::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `i32::MAX * 5_i32`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:213:14
|
LL | let _n = i64::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `i64::MAX * 5_i64`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:216:14
|
LL | let _n = i128::MAX * 5;
| ^^^^^^^^^^^^^ attempt to compute `i128::MAX * 5_i128`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:219:14
|
LL | let _n = isize::MAX * 5;
| ^^^^^^^^^^^^^^ attempt to compute `isize::MAX * 5_isize`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:222:14
|
LL | let _n = usize::MAX * 5;
| ^^^^^^^^^^^^^^ attempt to compute `usize::MAX * 5_usize`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:210:14
|
LL | let _n = i8::MAX * i8::MAX;
| ^^^^^^^^^^^^^^^^^ attempt to compute `i8::MAX * i8::MAX`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:213:14
|
LL | let _n = i16::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `i16::MAX * 5_i16`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:216:14
|
LL | let _n = i32::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `i32::MAX * 5_i32`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:219:14
|
LL | let _n = i64::MAX * 5;
| ^^^^^^^^^^^^ attempt to compute `i64::MAX * 5_i64`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:222:14
|
LL | let _n = i128::MAX * 5;
| ^^^^^^^^^^^^^ attempt to compute `i128::MAX * 5_i128`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/lint-overflowing-ops.rs:225:14
|
LL | let _n = -i8::MIN;
| ^^^^^^^^ attempt to negate `i8::MIN`, which would overflow
LL | let _n = isize::MAX * 5;
| ^^^^^^^^^^^^^^ attempt to compute `isize::MAX * 5_isize`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:230:14
@@ -843,219 +843,291 @@ LL | let _n = &(1u128 / 0);
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:245:14
|
LL | let _n = 1i8 / 0;
| ^^^^^^^ attempt to divide `1_i8` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:246:15
|
LL | let _n = &(1i8 / 0);
| ^^^^^^^^^ attempt to divide `1_i8` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:248:14
|
LL | let _n = 1i16 / 0;
| ^^^^^^^^ attempt to divide `1_i16` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:249:15
|
LL | let _n = &(1i16 / 0);
| ^^^^^^^^^^ attempt to divide `1_i16` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:251:14
|
LL | let _n = 1i32 / 0;
| ^^^^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:252:15
|
LL | let _n = &(1i32 / 0);
| ^^^^^^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:254:14
|
LL | let _n = 1i64 / 0;
| ^^^^^^^^ attempt to divide `1_i64` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:255:15
|
LL | let _n = &(1i64 / 0);
| ^^^^^^^^^^ attempt to divide `1_i64` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:257:14
|
LL | let _n = 1i128 / 0;
| ^^^^^^^^^ attempt to divide `1_i128` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:258:15
|
LL | let _n = &(1i128 / 0);
| ^^^^^^^^^^^ attempt to divide `1_i128` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:260:14
|
LL | let _n = 1isize / 0;
| ^^^^^^^^^^ attempt to divide `1_isize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:261:15
|
LL | let _n = &(1isize / 0);
| ^^^^^^^^^^^^ attempt to divide `1_isize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:263:14
|
LL | let _n = 1usize / 0;
| ^^^^^^^^^^ attempt to divide `1_usize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:264:15
--> $DIR/lint-overflowing-ops.rs:246:15
|
LL | let _n = &(1usize / 0);
| ^^^^^^^^^^^^ attempt to divide `1_usize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:248:14
|
LL | let _n = 1i8 / 0;
| ^^^^^^^ attempt to divide `1_i8` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:249:15
|
LL | let _n = &(1i8 / 0);
| ^^^^^^^^^ attempt to divide `1_i8` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:250:14
|
LL | let _n = i8::MIN / -1;
| ^^^^^^^^^^^^ attempt to compute `i8::MIN / -1_i8`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:251:15
|
LL | let _n = &(i8::MIN / -1);
| ^^^^^^^^^^^^^^ attempt to compute `i8::MIN / -1_i8`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:251:15
|
LL | let _n = &(i8::MIN / -1);
| ^^^^^^^^^^^^^^ overflow in signed division (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:251:14
|
LL | let _n = &(i8::MIN / -1);
| ^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:254:14
|
LL | let _n = 1i16 / 0;
| ^^^^^^^^ attempt to divide `1_i16` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:255:15
|
LL | let _n = &(1i16 / 0);
| ^^^^^^^^^^ attempt to divide `1_i16` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:256:14
|
LL | let _n = i16::MIN / -1;
| ^^^^^^^^^^^^^ attempt to compute `i16::MIN / -1_i16`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:257:15
|
LL | let _n = &(i16::MIN / -1);
| ^^^^^^^^^^^^^^^ attempt to compute `i16::MIN / -1_i16`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:257:15
|
LL | let _n = &(i16::MIN / -1);
| ^^^^^^^^^^^^^^^ overflow in signed division (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:257:14
|
LL | let _n = &(i16::MIN / -1);
| ^^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:260:14
|
LL | let _n = 1i32 / 0;
| ^^^^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:261:15
|
LL | let _n = &(1i32 / 0);
| ^^^^^^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:262:14
|
LL | let _n = i32::MIN / -1;
| ^^^^^^^^^^^^^ attempt to compute `i32::MIN / -1_i32`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:263:15
|
LL | let _n = &(i32::MIN / -1);
| ^^^^^^^^^^^^^^^ attempt to compute `i32::MIN / -1_i32`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:263:15
|
LL | let _n = &(i32::MIN / -1);
| ^^^^^^^^^^^^^^^ overflow in signed division (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:263:14
|
LL | let _n = &(i32::MIN / -1);
| ^^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:266:14
|
LL | let _n = 1i64 / 0;
| ^^^^^^^^ attempt to divide `1_i64` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:267:15
|
LL | let _n = &(1i64 / 0);
| ^^^^^^^^^^ attempt to divide `1_i64` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:268:14
|
LL | let _n = i64::MIN / -1;
| ^^^^^^^^^^^^^ attempt to compute `i64::MIN / -1_i64`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:269:15
|
LL | let _n = &(i64::MIN / -1);
| ^^^^^^^^^^^^^^^ attempt to compute `i64::MIN / -1_i64`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:269:15
|
LL | let _n = &(i64::MIN / -1);
| ^^^^^^^^^^^^^^^ overflow in signed division (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:269:14
|
LL | let _n = &(i64::MIN / -1);
| ^^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:272:14
|
LL | let _n = 1i128 / 0;
| ^^^^^^^^^ attempt to divide `1_i128` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:273:15
|
LL | let _n = &(1i128 / 0);
| ^^^^^^^^^^^ attempt to divide `1_i128` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:274:14
|
LL | let _n = i128::MIN / -1;
| ^^^^^^^^^^^^^^ attempt to compute `i128::MIN / -1_i128`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:275:15
|
LL | let _n = &(i128::MIN / -1);
| ^^^^^^^^^^^^^^^^ attempt to compute `i128::MIN / -1_i128`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:275:15
|
LL | let _n = &(i128::MIN / -1);
| ^^^^^^^^^^^^^^^^ overflow in signed division (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:275:14
|
LL | let _n = &(i128::MIN / -1);
| ^^^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:278:14
|
LL | let _n = 1isize / 0;
| ^^^^^^^^^^ attempt to divide `1_isize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:279:15
|
LL | let _n = &(1isize / 0);
| ^^^^^^^^^^^^ attempt to divide `1_isize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:280:14
|
LL | let _n = isize::MIN / -1;
| ^^^^^^^^^^^^^^^ attempt to compute `isize::MIN / -1_isize`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:281:15
|
LL | let _n = &(isize::MIN / -1);
| ^^^^^^^^^^^^^^^^^ attempt to compute `isize::MIN / -1_isize`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:281:15
|
LL | let _n = &(isize::MIN / -1);
| ^^^^^^^^^^^^^^^^^ overflow in signed division (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:281:14
|
LL | let _n = &(isize::MIN / -1);
| ^^^^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:286:14
|
LL | let _n = 1u8 % 0;
| ^^^^^^^ attempt to calculate the remainder of `1_u8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:269:15
--> $DIR/lint-overflowing-ops.rs:287:15
|
LL | let _n = &(1u8 % 0);
| ^^^^^^^^^ attempt to calculate the remainder of `1_u8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:271:14
--> $DIR/lint-overflowing-ops.rs:289:14
|
LL | let _n = 1u16 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_u16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:272:15
--> $DIR/lint-overflowing-ops.rs:290:15
|
LL | let _n = &(1u16 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_u16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:274:14
--> $DIR/lint-overflowing-ops.rs:292:14
|
LL | let _n = 1u32 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_u32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:275:15
--> $DIR/lint-overflowing-ops.rs:293:15
|
LL | let _n = &(1u32 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_u32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:277:14
--> $DIR/lint-overflowing-ops.rs:295:14
|
LL | let _n = 1u64 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_u64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:278:15
--> $DIR/lint-overflowing-ops.rs:296:15
|
LL | let _n = &(1u64 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_u64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:280:14
--> $DIR/lint-overflowing-ops.rs:298:14
|
LL | let _n = 1u128 % 0;
| ^^^^^^^^^ attempt to calculate the remainder of `1_u128` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:281:15
--> $DIR/lint-overflowing-ops.rs:299:15
|
LL | let _n = &(1u128 % 0);
| ^^^^^^^^^^^ attempt to calculate the remainder of `1_u128` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:283:14
|
LL | let _n = 1i8 % 0;
| ^^^^^^^ attempt to calculate the remainder of `1_i8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:284:15
|
LL | let _n = &(1i8 % 0);
| ^^^^^^^^^ attempt to calculate the remainder of `1_i8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:286:14
|
LL | let _n = 1i16 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_i16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:287:15
|
LL | let _n = &(1i16 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_i16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:289:14
|
LL | let _n = 1i32 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_i32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:290:15
|
LL | let _n = &(1i32 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_i32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:292:14
|
LL | let _n = 1i64 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_i64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:293:15
|
LL | let _n = &(1i64 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_i64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:295:14
|
LL | let _n = 1i128 % 0;
| ^^^^^^^^^ attempt to calculate the remainder of `1_i128` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:296:15
|
LL | let _n = &(1i128 % 0);
| ^^^^^^^^^^^ attempt to calculate the remainder of `1_i128` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:298:14
|
LL | let _n = 1isize % 0;
| ^^^^^^^^^^ attempt to calculate the remainder of `1_isize` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:299:15
|
LL | let _n = &(1isize % 0);
| ^^^^^^^^^^^^ attempt to calculate the remainder of `1_isize` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:301:14
|
@@ -1068,161 +1140,234 @@ error: this operation will panic at runtime
LL | let _n = &(1usize % 0);
| ^^^^^^^^^^^^ attempt to calculate the remainder of `1_usize` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:304:14
|
LL | let _n = 1i8 % 0;
| ^^^^^^^ attempt to calculate the remainder of `1_i8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:305:15
|
LL | let _n = &(1i8 % 0);
| ^^^^^^^^^ attempt to calculate the remainder of `1_i8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:306:14
|
LL | let _n = i8::MIN % -1;
| ^^^^^^^^^^^^ attempt to compute `i8::MIN % -1_i8`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:307:15
|
LL | let _n = &(i8::MIN % -1);
| ^^^^^^^^^^^^^^ attempt to compute `i8::MIN % -1_i8`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:307:15
|
LL | let _n = &(i8::MIN % -1);
| ^^^^^^^^^^^^^^ overflow in signed remainder (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:307:14
|
LL | let _n = &(i8::MIN % -1);
| ^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:310:14
|
LL | let _n = 1i16 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_i16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:311:15
|
LL | let _n = &(1i16 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_i16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:312:14
|
LL | let _n = i16::MIN % -1;
| ^^^^^^^^^^^^^ attempt to compute `i16::MIN % -1_i16`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:313:15
|
LL | let _n = &(i16::MIN % -1);
| ^^^^^^^^^^^^^^^ attempt to compute `i16::MIN % -1_i16`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:313:15
|
LL | let _n = &(i16::MIN % -1);
| ^^^^^^^^^^^^^^^ overflow in signed remainder (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:313:14
|
LL | let _n = &(i16::MIN % -1);
| ^^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:316:14
|
LL | let _n = 1i32 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_i32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:317:15
|
LL | let _n = &(1i32 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_i32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:318:14
|
LL | let _n = i32::MIN % -1;
| ^^^^^^^^^^^^^ attempt to compute `i32::MIN % -1_i32`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:319:15
|
LL | let _n = &(i32::MIN % -1);
| ^^^^^^^^^^^^^^^ attempt to compute `i32::MIN % -1_i32`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:319:15
|
LL | let _n = &(i32::MIN % -1);
| ^^^^^^^^^^^^^^^ overflow in signed remainder (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:319:14
|
LL | let _n = &(i32::MIN % -1);
| ^^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:322:14
|
LL | let _n = 1i64 % 0;
| ^^^^^^^^ attempt to calculate the remainder of `1_i64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:323:15
|
LL | let _n = &(1i64 % 0);
| ^^^^^^^^^^ attempt to calculate the remainder of `1_i64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:324:14
|
LL | let _n = i64::MIN % -1;
| ^^^^^^^^^^^^^ attempt to compute `i64::MIN % -1_i64`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:325:15
|
LL | let _n = &(i64::MIN % -1);
| ^^^^^^^^^^^^^^^ attempt to compute `i64::MIN % -1_i64`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:325:15
|
LL | let _n = &(i64::MIN % -1);
| ^^^^^^^^^^^^^^^ overflow in signed remainder (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:325:14
|
LL | let _n = &(i64::MIN % -1);
| ^^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:328:14
|
LL | let _n = 1i128 % 0;
| ^^^^^^^^^ attempt to calculate the remainder of `1_i128` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:329:15
|
LL | let _n = &(1i128 % 0);
| ^^^^^^^^^^^ attempt to calculate the remainder of `1_i128` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:330:14
|
LL | let _n = i128::MIN % -1;
| ^^^^^^^^^^^^^^ attempt to compute `i128::MIN % -1_i128`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:331:15
|
LL | let _n = &(i128::MIN % -1);
| ^^^^^^^^^^^^^^^^ attempt to compute `i128::MIN % -1_i128`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:331:15
|
LL | let _n = &(i128::MIN % -1);
| ^^^^^^^^^^^^^^^^ overflow in signed remainder (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:331:14
|
LL | let _n = &(i128::MIN % -1);
| ^^^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:334:14
|
LL | let _n = 1isize % 0;
| ^^^^^^^^^^ attempt to calculate the remainder of `1_isize` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:335:15
|
LL | let _n = &(1isize % 0);
| ^^^^^^^^^^^^ attempt to calculate the remainder of `1_isize` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:336:14
|
LL | let _n = isize::MIN % -1;
| ^^^^^^^^^^^^^^^ attempt to compute `isize::MIN % -1_isize`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:337:15
|
LL | let _n = &(isize::MIN % -1);
| ^^^^^^^^^^^^^^^^^ attempt to compute `isize::MIN % -1_isize`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/lint-overflowing-ops.rs:337:15
|
LL | let _n = &(isize::MIN % -1);
| ^^^^^^^^^^^^^^^^^ overflow in signed remainder (dividing MIN by -1)
note: erroneous constant encountered
--> $DIR/lint-overflowing-ops.rs:337:14
|
LL | let _n = &(isize::MIN % -1);
| ^^^^^^^^^^^^^^^^^^
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:341:14
|
LL | let _n = [1, 2, 3][4];
| ^^^^^^^^^^^^ index out of bounds: the length is 3 but the index is 4
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:307:15
--> $DIR/lint-overflowing-ops.rs:342:15
|
LL | let _n = &([1, 2, 3][4]);
| ^^^^^^^^^^^^^^ index out of bounds: the length is 3 but the index is 4
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:311:36
|
LL | assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^^ attempt to compute `isize::MIN / -1_isize`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:313:36
|
LL | assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^ attempt to compute `i8::MIN / -1_i8`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:315:36
|
LL | assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i16::MIN / -1_i16`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:317:36
|
LL | assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i32::MIN / -1_i32`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:319:36
|
LL | assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i64::MIN / -1_i64`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:321:36
|
LL | assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^ attempt to compute `i128::MIN / -1_i128`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:323:36
|
LL | assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
| ^^^^^^^^^^ attempt to divide `1_isize` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:325:36
|
LL | assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
| ^^^^^^^ attempt to divide `1_i8` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:327:36
|
LL | assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide `1_i16` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:329:36
|
LL | assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:331:36
|
LL | assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide `1_i64` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:333:36
|
LL | assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
| ^^^^^^^^^ attempt to divide `1_i128` by zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:335:36
|
LL | assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^^ attempt to compute `isize::MIN % -1_isize`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:337:36
|
LL | assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^ attempt to compute `i8::MIN % -1_i8`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:339:36
|
LL | assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i16::MIN % -1_i16`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:341:36
|
LL | assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i32::MIN % -1_i32`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:343:36
|
LL | assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i64::MIN % -1_i64`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:345:36
|
LL | assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^ attempt to compute `i128::MIN % -1_i128`, which would overflow
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:347:36
|
LL | assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
| ^^^^^^^^^^ attempt to calculate the remainder of `1_isize` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:349:36
|
LL | assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
| ^^^^^^^ attempt to calculate the remainder of `1_i8` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:351:36
|
LL | assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder of `1_i16` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:353:36
|
LL | assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder of `1_i32` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:355:36
|
LL | assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder of `1_i64` with a divisor of zero
error: this operation will panic at runtime
--> $DIR/lint-overflowing-ops.rs:357:36
|
LL | assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
| ^^^^^^^^^ attempt to calculate the remainder of `1_i128` with a divisor of zero
error: aborting due to 203 previous errors
error: aborting due to 215 previous errors
For more information about this error, try `rustc --explain E0080`.
tests/ui/lint/lint-overflowing-ops.rs
+62 -78
View File
@@ -184,6 +184,9 @@ fn main() {
let _n = 1usize - 5; //~ ERROR: arithmetic operation will overflow
let _n = &(1usize - 5); //~ ERROR: arithmetic operation will overflow
let _n = -i8::MIN; //~ ERROR this arithmetic operation will overflow
let _n = &(-i8::MIN); //~ ERROR this arithmetic operation will overflow
// Multiplication
let _n = u8::MAX * 5; //~ ERROR: arithmetic operation will overflow
@@ -201,6 +204,9 @@ fn main() {
let _n = u128::MAX * 5; //~ ERROR: arithmetic operation will overflow
let _n = &(u128::MAX * 5); //~ ERROR: arithmetic operation will overflow
let _n = usize::MAX * 5; //~ ERROR: arithmetic operation will overflow
let _n = &(usize::MAX * 5); //~ ERROR: arithmetic operation will overflow
let _n = i8::MAX * i8::MAX; //~ ERROR: arithmetic operation will overflow
let _n = &(i8::MAX * i8::MAX); //~ ERROR: arithmetic operation will overflow
@@ -219,12 +225,6 @@ fn main() {
let _n = isize::MAX * 5; //~ ERROR: arithmetic operation will overflow
let _n = &(isize::MAX * 5); //~ ERROR: arithmetic operation will overflow
let _n = usize::MAX * 5; //~ ERROR: arithmetic operation will overflow
let _n = &(usize::MAX * 5); //~ ERROR: arithmetic operation will overflow
let _n = -i8::MIN; //~ ERROR this arithmetic operation will overflow
let _n = &(-i8::MIN); //~ ERROR this arithmetic operation will overflow
// Division
let _n = 1u8 / 0; //~ ERROR: this operation will panic at runtime
@@ -242,26 +242,44 @@ fn main() {
let _n = 1u128 / 0; //~ ERROR: this operation will panic at runtime
let _n = &(1u128 / 0); //~ ERROR: this operation will panic at runtime
let _n = 1usize / 0; //~ ERROR: this operation will panic at runtime
let _n = &(1usize / 0); //~ ERROR: this operation will panic at runtime
let _n = 1i8 / 0; //~ ERROR: this operation will panic at runtime
let _n = &(1i8 / 0); //~ ERROR: this operation will panic at runtime
let _n = i8::MIN / -1; //~ ERROR: this operation will panic at runtime
let _n = &(i8::MIN / -1); //~ ERROR: this operation will panic at runtime
//~^ERROR: evaluation of constant value failed
let _n = 1i16 / 0; //~ ERROR: this operation will panic at runtime
let _n = &(1i16 / 0); //~ ERROR: this operation will panic at runtime
let _n = i16::MIN / -1; //~ ERROR: this operation will panic at runtime
let _n = &(i16::MIN / -1); //~ ERROR: this operation will panic at runtime
//~^ERROR: evaluation of constant value failed
let _n = 1i32 / 0; //~ ERROR: this operation will panic at runtime
let _n = &(1i32 / 0); //~ ERROR: this operation will panic at runtime
let _n = i32::MIN / -1; //~ ERROR: this operation will panic at runtime
let _n = &(i32::MIN / -1); //~ ERROR: this operation will panic at runtime
//~^ERROR: evaluation of constant value failed
let _n = 1i64 / 0; //~ ERROR: this operation will panic at runtime
let _n = &(1i64 / 0); //~ ERROR: this operation will panic at runtime
let _n = i64::MIN / -1; //~ ERROR: this operation will panic at runtime
let _n = &(i64::MIN / -1); //~ ERROR: this operation will panic at runtime
//~^ERROR: evaluation of constant value failed
let _n = 1i128 / 0; //~ ERROR: this operation will panic at runtime
let _n = &(1i128 / 0); //~ ERROR: this operation will panic at runtime
let _n = i128::MIN / -1; //~ ERROR: this operation will panic at runtime
let _n = &(i128::MIN / -1); //~ ERROR: this operation will panic at runtime
//~^ERROR: evaluation of constant value failed
let _n = 1isize / 0; //~ ERROR: this operation will panic at runtime
let _n = &(1isize / 0); //~ ERROR: this operation will panic at runtime
let _n = 1usize / 0; //~ ERROR: this operation will panic at runtime
let _n = &(1usize / 0); //~ ERROR: this operation will panic at runtime
let _n = isize::MIN / -1; //~ ERROR: this operation will panic at runtime
let _n = &(isize::MIN / -1); //~ ERROR: this operation will panic at runtime
//~^ERROR: evaluation of constant value failed
// Modulus
@@ -280,80 +298,46 @@ fn main() {
let _n = 1u128 % 0; //~ ERROR: this operation will panic at runtime
let _n = &(1u128 % 0); //~ ERROR: this operation will panic at runtime
let _n = 1i8 % 0; //~ ERROR: this operation will panic at runtime
let _n = &(1i8 % 0); //~ ERROR: this operation will panic at runtime
let _n = 1i16 % 0; //~ ERROR: this operation will panic at runtime
let _n = &(1i16 % 0); //~ ERROR: this operation will panic at runtime
let _n = 1i32 % 0; //~ ERROR: this operation will panic at runtime
let _n = &(1i32 % 0); //~ ERROR: this operation will panic at runtime
let _n = 1i64 % 0; //~ ERROR: this operation will panic at runtime
let _n = &(1i64 % 0); //~ ERROR: this operation will panic at runtime
let _n = 1i128 % 0; //~ ERROR: this operation will panic at runtime
let _n = &(1i128 % 0); //~ ERROR: this operation will panic at runtime
let _n = 1isize % 0; //~ ERROR: this operation will panic at runtime
let _n = &(1isize % 0); //~ ERROR: this operation will panic at runtime
let _n = 1usize % 0; //~ ERROR: this operation will panic at runtime
let _n = &(1usize % 0); //~ ERROR: this operation will panic at runtime
let _n = 1i8 % 0; //~ ERROR: this operation will panic at runtime
let _n = &(1i8 % 0); //~ ERROR: this operation will panic at runtime
let _n = i8::MIN % -1; //~ ERROR: this operation will panic at runtime
let _n = &(i8::MIN % -1); //~ ERROR: this operation will panic at runtime
//~^ERROR: evaluation of constant value failed
let _n = 1i16 % 0; //~ ERROR: this operation will panic at runtime
let _n = &(1i16 % 0); //~ ERROR: this operation will panic at runtime
let _n = i16::MIN % -1; //~ ERROR: this operation will panic at runtime
let _n = &(i16::MIN % -1); //~ ERROR: this operation will panic at runtime
//~^ERROR: evaluation of constant value failed
let _n = 1i32 % 0; //~ ERROR: this operation will panic at runtime
let _n = &(1i32 % 0); //~ ERROR: this operation will panic at runtime
let _n = i32::MIN % -1; //~ ERROR: this operation will panic at runtime
let _n = &(i32::MIN % -1); //~ ERROR: this operation will panic at runtime
//~^ERROR: evaluation of constant value failed
let _n = 1i64 % 0; //~ ERROR: this operation will panic at runtime
let _n = &(1i64 % 0); //~ ERROR: this operation will panic at runtime
let _n = i64::MIN % -1; //~ ERROR: this operation will panic at runtime
let _n = &(i64::MIN % -1); //~ ERROR: this operation will panic at runtime
//~^ERROR: evaluation of constant value failed
let _n = 1i128 % 0; //~ ERROR: this operation will panic at runtime
let _n = &(1i128 % 0); //~ ERROR: this operation will panic at runtime
let _n = i128::MIN % -1; //~ ERROR: this operation will panic at runtime
let _n = &(i128::MIN % -1); //~ ERROR: this operation will panic at runtime
//~^ERROR: evaluation of constant value failed
let _n = 1isize % 0; //~ ERROR: this operation will panic at runtime
let _n = &(1isize % 0); //~ ERROR: this operation will panic at runtime
let _n = isize::MIN % -1; //~ ERROR: this operation will panic at runtime
let _n = &(isize::MIN % -1); //~ ERROR: this operation will panic at runtime
//~^ERROR: evaluation of constant value failed
// Out of bounds access
let _n = [1, 2, 3][4]; //~ ERROR: this operation will panic at runtime
let _n = &([1, 2, 3][4]); //~ ERROR: this operation will panic at runtime
// issue-8460-const
assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
//~^ ERROR operation will panic
assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
//~^ ERROR operation will panic
}