Deny the overflowing_literals lint for all editions

ollie27 · ollie27 · commit c6549681008a · 2019-01-17T09:22:52.000Z
diff --git a/src/doc/rustc/src/lints/listing/deny-by-default.md b/src/doc/rustc/src/lints/listing/deny-by-default.md
@@ -149,6 +149,26 @@ error: const items should never be #[no_mangle]
   |
 ```
 
+## overflowing-literals
+
+This lint detects literal out of range for its type. Some
+example code that triggers this lint:
+
+```rust,compile_fail
+let x: u8 = 1000;
+```
+
+This will produce:
+
+```text
+error: literal out of range for u8
+ --> src/main.rs:2:17
+  |
+2 |     let x: u8 = 1000;
+  |                 ^^^^
+  |
+```
+
 ## parenthesized-params-in-types-and-modules
 
 This lint detects incorrect parentheses. Some example code that triggers this
diff --git a/src/doc/rustc/src/lints/listing/warn-by-default.md b/src/doc/rustc/src/lints/listing/warn-by-default.md
@@ -285,26 +285,6 @@ warning: functions generic over types must be mangled
   |
 ```
 
-## overflowing-literals
-
-This lint detects literal out of range for its type. Some
-example code that triggers this lint:
-
-```rust
-let x: u8 = 1000;
-```
-
-This will produce:
-
-```text
-warning: literal out of range for u8
- --> src/main.rs:2:17
-  |
-2 |     let x: u8 = 1000;
-  |                 ^^^^
-  |
-```
-
 ## path-statements
 
 This lint detects path statements with no effect. Some example code that
diff --git a/src/librustc_lint/types.rs b/src/librustc_lint/types.rs
@@ -15,7 +15,6 @@ use std::{i8, i16, i32, i64, u8, u16, u32, u64, f32, f64};
 use syntax::{ast, attr};
 use syntax::errors::Applicability;
 use rustc_target::spec::abi::Abi;
-use syntax::edition::Edition;
 use syntax_pos::Span;
 use syntax::source_map;
 
@@ -29,9 +28,8 @@ declare_lint! {
 
 declare_lint! {
     OVERFLOWING_LITERALS,
-    Warn,
-    "literal out of range for its type",
-    Edition::Edition2018 => Deny
+    Deny,
+    "literal out of range for its type"
 }
 
 declare_lint! {
diff --git a/src/test/ui/lint/deny-overflowing-literals.rs b/src/test/ui/lint/deny-overflowing-literals.rs
@@ -1,5 +1,3 @@
-// edition:2018
-
 fn main() {
     let x: u8 = 256;
     //~^ error: literal out of range for u8
diff --git a/src/test/ui/lint/deny-overflowing-literals.stderr b/src/test/ui/lint/deny-overflowing-literals.stderr
@@ -1,5 +1,5 @@
 error: literal out of range for u8
-  --> $DIR/edition-deny-overflowing-literals-2018.rs:4:17
+  --> $DIR/deny-overflowing-literals.rs:2:17
    |
 LL |     let x: u8 = 256;
    |                 ^^^
diff --git a/src/test/ui/lint/lint-type-limits2.rs b/src/test/ui/lint/lint-type-limits2.rs
@@ -1,4 +1,5 @@
 #![allow(dead_code)]
+#![warn(overflowing_literals)]
 
 // compile-flags: -D unused-comparisons
 fn main() { }
diff --git a/src/test/ui/lint/lint-type-limits2.stderr b/src/test/ui/lint/lint-type-limits2.stderr
@@ -1,18 +1,22 @@
 error: comparison is useless due to type limits
-  --> $DIR/lint-type-limits2.rs:12:5
+  --> $DIR/lint-type-limits2.rs:13:5
    |
 LL |     128 > bar() //~ ERROR comparison is useless due to type limits
    |     ^^^^^^^^^^^
    |
    = note: requested on the command line with `-D unused-comparisons`
 
 warning: literal out of range for i8
-  --> $DIR/lint-type-limits2.rs:12:5
+  --> $DIR/lint-type-limits2.rs:13:5
    |
 LL |     128 > bar() //~ ERROR comparison is useless due to type limits
    |     ^^^
    |
-   = note: #[warn(overflowing_literals)] on by default
+note: lint level defined here
+  --> $DIR/lint-type-limits2.rs:2:9
+   |
+LL | #![warn(overflowing_literals)]
+   |         ^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/lint/lint-type-limits3.rs b/src/test/ui/lint/lint-type-limits3.rs
@@ -1,4 +1,5 @@
 #![allow(dead_code)]
+#![warn(overflowing_literals)]
 
 // compile-flags: -D unused-comparisons
 fn main() { }
diff --git a/src/test/ui/lint/lint-type-limits3.stderr b/src/test/ui/lint/lint-type-limits3.stderr
@@ -1,18 +1,22 @@
 error: comparison is useless due to type limits
-  --> $DIR/lint-type-limits3.rs:8:11
+  --> $DIR/lint-type-limits3.rs:9:11
    |
 LL |     while 200 != i { //~ ERROR comparison is useless due to type limits
    |           ^^^^^^^^
    |
    = note: requested on the command line with `-D unused-comparisons`
 
 warning: literal out of range for i8
-  --> $DIR/lint-type-limits3.rs:8:11
+  --> $DIR/lint-type-limits3.rs:9:11
    |
 LL |     while 200 != i { //~ ERROR comparison is useless due to type limits
    |           ^^^
    |
-   = note: #[warn(overflowing_literals)] on by default
+note: lint level defined here
+  --> $DIR/lint-type-limits3.rs:2:9
+   |
+LL | #![warn(overflowing_literals)]
+   |         ^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/lint/type-overflow.rs b/src/test/ui/lint/type-overflow.rs
@@ -1,4 +1,5 @@
 // compile-pass
+#![warn(overflowing_literals)]
 
 fn main() {
     let error = 255i8; //~WARNING literal out of range for i8
diff --git a/src/test/ui/lint/type-overflow.stderr b/src/test/ui/lint/type-overflow.stderr
@@ -1,37 +1,41 @@
 warning: literal out of range for i8
-  --> $DIR/type-overflow.rs:4:17
+  --> $DIR/type-overflow.rs:5:17
    |
 LL |     let error = 255i8; //~WARNING literal out of range for i8
    |                 ^^^^^
    |
-   = note: #[warn(overflowing_literals)] on by default
+note: lint level defined here
+  --> $DIR/type-overflow.rs:2:9
+   |
+LL | #![warn(overflowing_literals)]
+   |         ^^^^^^^^^^^^^^^^^^^^
 
 warning: literal out of range for i8
-  --> $DIR/type-overflow.rs:9:16
+  --> $DIR/type-overflow.rs:10:16
    |
 LL |     let fail = 0b1000_0001i8; //~WARNING literal out of range for i8
    |                ^^^^^^^^^^^^^ help: consider using `u8` instead: `0b1000_0001u8`
    |
    = note: the literal `0b1000_0001i8` (decimal `129`) does not fit into an `i8` and will become `-127i8`
 
 warning: literal out of range for i64
-  --> $DIR/type-overflow.rs:11:16
+  --> $DIR/type-overflow.rs:12:16
    |
 LL |     let fail = 0x8000_0000_0000_0000i64; //~WARNING literal out of range for i64
    |                ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `u64` instead: `0x8000_0000_0000_0000u64`
    |
    = note: the literal `0x8000_0000_0000_0000i64` (decimal `9223372036854775808`) does not fit into an `i64` and will become `-9223372036854775808i64`
 
 warning: literal out of range for u32
-  --> $DIR/type-overflow.rs:13:16
+  --> $DIR/type-overflow.rs:14:16
    |
 LL |     let fail = 0x1_FFFF_FFFFu32; //~WARNING literal out of range for u32
    |                ^^^^^^^^^^^^^^^^ help: consider using `u64` instead: `0x1_FFFF_FFFFu64`
    |
    = note: the literal `0x1_FFFF_FFFFu32` (decimal `8589934591`) does not fit into an `u32` and will become `4294967295u32`
 
 warning: literal out of range for i128
-  --> $DIR/type-overflow.rs:15:22
+  --> $DIR/type-overflow.rs:16:22
    |
 LL |     let fail: i128 = 0x8000_0000_0000_0000_0000_0000_0000_0000;
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -40,7 +44,7 @@ LL |     let fail: i128 = 0x8000_0000_0000_0000_0000_0000_0000_0000;
    = help: consider using `u128` instead
 
 warning: literal out of range for i32
-  --> $DIR/type-overflow.rs:18:16
+  --> $DIR/type-overflow.rs:19:16
    |
 LL |     let fail = 0x8FFF_FFFF_FFFF_FFFE; //~WARNING literal out of range for i32
    |                ^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +53,7 @@ LL |     let fail = 0x8FFF_FFFF_FFFF_FFFE; //~WARNING literal out of range for i
    = help: consider using `i128` instead
 
 warning: literal out of range for i8
-  --> $DIR/type-overflow.rs:20:17
+  --> $DIR/type-overflow.rs:21:17
    |
 LL |     let fail = -0b1111_1111i8; //~WARNING literal out of range for i8
    |                 ^^^^^^^^^^^^^ help: consider using `i16` instead: `0b1111_1111i16`

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,3 @@`
`1`		`-// edition:2018`
`2`		`-`
`3`	`1`	`fn main() {`
`4`	`2`	`let x: u8 = 256;`
`5`	`3`	`//~^ error: literal out of range for u8`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`error: literal out of range for u8`
`2`		`- --> $DIR/edition-deny-overflowing-literals-2018.rs:4:17`
	`2`	`+ --> $DIR/deny-overflowing-literals.rs:2:17`
`3`	`3`	`\|`
`4`	`4`	`LL \| let x: u8 = 256;`
`5`	`5`	`\| ^^^`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`#![allow(dead_code)]`
	`2`	`+#![warn(overflowing_literals)]`
`2`	`3`
`3`	`4`	`// compile-flags: -D unused-comparisons`
`4`	`5`	`fn main() { }`
Original file line number	Diff line number	Diff line change
`@@ -1,18 +1,22 @@`
`1`	`1`	`error: comparison is useless due to type limits`
`2`		`- --> $DIR/lint-type-limits2.rs:12:5`
	`2`	`+ --> $DIR/lint-type-limits2.rs:13:5`
`3`	`3`	`\|`
`4`	`4`	`LL \| 128 > bar() //~ ERROR comparison is useless due to type limits`
`5`	`5`	`\| ^^^^^^^^^^^`
`6`	`6`	`\|`
`7`	`7`	= note: requested on the command line with `-D unused-comparisons`
`8`	`8`
`9`	`9`	`warning: literal out of range for i8`
`10`		`- --> $DIR/lint-type-limits2.rs:12:5`
	`10`	`+ --> $DIR/lint-type-limits2.rs:13:5`
`11`	`11`	`\|`
`12`	`12`	`LL \| 128 > bar() //~ ERROR comparison is useless due to type limits`
`13`	`13`	`\| ^^^`
`14`	`14`	`\|`
`15`		`- = note: #[warn(overflowing_literals)] on by default`
	`15`	`+note: lint level defined here`
	`16`	`+ --> $DIR/lint-type-limits2.rs:2:9`
	`17`	`+ \|`
	`18`	`+LL \| #![warn(overflowing_literals)]`
	`19`	`+ \| ^^^^^^^^^^^^^^^^^^^^`
`16`	`20`
`17`	`21`	`error: aborting due to previous error`
`18`	`22`
Original file line number	Diff line number	Diff line change
`@@ -1,18 +1,22 @@`
`1`	`1`	`error: comparison is useless due to type limits`
`2`		`- --> $DIR/lint-type-limits3.rs:8:11`
	`2`	`+ --> $DIR/lint-type-limits3.rs:9:11`
`3`	`3`	`\|`
`4`	`4`	`LL \| while 200 != i { //~ ERROR comparison is useless due to type limits`
`5`	`5`	`\| ^^^^^^^^`
`6`	`6`	`\|`
`7`	`7`	= note: requested on the command line with `-D unused-comparisons`
`8`	`8`
`9`	`9`	`warning: literal out of range for i8`
`10`		`- --> $DIR/lint-type-limits3.rs:8:11`
	`10`	`+ --> $DIR/lint-type-limits3.rs:9:11`
`11`	`11`	`\|`
`12`	`12`	`LL \| while 200 != i { //~ ERROR comparison is useless due to type limits`
`13`	`13`	`\| ^^^`
`14`	`14`	`\|`
`15`		`- = note: #[warn(overflowing_literals)] on by default`
	`15`	`+note: lint level defined here`
	`16`	`+ --> $DIR/lint-type-limits3.rs:2:9`
	`17`	`+ \|`
	`18`	`+LL \| #![warn(overflowing_literals)]`
	`19`	`+ \| ^^^^^^^^^^^^^^^^^^^^`
`16`	`20`
`17`	`21`	`error: aborting due to previous error`
`18`	`22`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`// compile-pass`
	`2`	`+#![warn(overflowing_literals)]`
`2`	`3`
`3`	`4`	`fn main() {`
`4`	`5`	`let error = 255i8; //~WARNING literal out of range for i8`
Original file line number	Diff line number	Diff line change
`@@ -1,37 +1,41 @@`
`1`	`1`	`warning: literal out of range for i8`
`2`		`- --> $DIR/type-overflow.rs:4:17`
	`2`	`+ --> $DIR/type-overflow.rs:5:17`
`3`	`3`	`\|`
`4`	`4`	`LL \| let error = 255i8; //~WARNING literal out of range for i8`
`5`	`5`	`\| ^^^^^`
`6`	`6`	`\|`
`7`		`- = note: #[warn(overflowing_literals)] on by default`
	`7`	`+note: lint level defined here`
	`8`	`+ --> $DIR/type-overflow.rs:2:9`
	`9`	`+ \|`
	`10`	`+LL \| #![warn(overflowing_literals)]`
	`11`	`+ \| ^^^^^^^^^^^^^^^^^^^^`
`8`	`12`
`9`	`13`	`warning: literal out of range for i8`
`10`		`- --> $DIR/type-overflow.rs:9:16`
	`14`	`+ --> $DIR/type-overflow.rs:10:16`
`11`	`15`	`\|`
`12`	`16`	`LL \| let fail = 0b1000_0001i8; //~WARNING literal out of range for i8`
`13`	`17`	\| ^^^^^^^^^^^^^ help: consider using `u8` instead: `0b1000_0001u8`
`14`	`18`	`\|`
`15`	`19`	= note: the literal `0b1000_0001i8` (decimal `129`) does not fit into an `i8` and will become `-127i8`
`16`	`20`
`17`	`21`	`warning: literal out of range for i64`
`18`		`- --> $DIR/type-overflow.rs:11:16`
	`22`	`+ --> $DIR/type-overflow.rs:12:16`
`19`	`23`	`\|`
`20`	`24`	`LL \| let fail = 0x8000_0000_0000_0000i64; //~WARNING literal out of range for i64`
`21`	`25`	\| ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `u64` instead: `0x8000_0000_0000_0000u64`
`22`	`26`	`\|`
`23`	`27`	= note: the literal `0x8000_0000_0000_0000i64` (decimal `9223372036854775808`) does not fit into an `i64` and will become `-9223372036854775808i64`
`24`	`28`
`25`	`29`	`warning: literal out of range for u32`
`26`		`- --> $DIR/type-overflow.rs:13:16`
	`30`	`+ --> $DIR/type-overflow.rs:14:16`
`27`	`31`	`\|`
`28`	`32`	`LL \| let fail = 0x1_FFFF_FFFFu32; //~WARNING literal out of range for u32`
`29`	`33`	\| ^^^^^^^^^^^^^^^^ help: consider using `u64` instead: `0x1_FFFF_FFFFu64`
`30`	`34`	`\|`
`31`	`35`	= note: the literal `0x1_FFFF_FFFFu32` (decimal `8589934591`) does not fit into an `u32` and will become `4294967295u32`
`32`	`36`
`33`	`37`	`warning: literal out of range for i128`
`34`		`- --> $DIR/type-overflow.rs:15:22`
	`38`	`+ --> $DIR/type-overflow.rs:16:22`
`35`	`39`	`\|`
`36`	`40`	`LL \| let fail: i128 = 0x8000_0000_0000_0000_0000_0000_0000_0000;`
`37`	`41`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`@@ -40,7 +44,7 @@ LL \| let fail: i128 = 0x8000_0000_0000_0000_0000_0000_0000_0000;`
`40`	`44`	= help: consider using `u128` instead
`41`	`45`
`42`	`46`	`warning: literal out of range for i32`
`43`		`- --> $DIR/type-overflow.rs:18:16`
	`47`	`+ --> $DIR/type-overflow.rs:19:16`
`44`	`48`	`\|`
`45`	`49`	`LL \| let fail = 0x8FFF_FFFF_FFFF_FFFE; //~WARNING literal out of range for i32`
`46`	`50`	`\| ^^^^^^^^^^^^^^^^^^^^^`
`@@ -49,7 +53,7 @@ LL \| let fail = 0x8FFF_FFFF_FFFF_FFFE; //~WARNING literal out of range for i`
`49`	`53`	= help: consider using `i128` instead
`50`	`54`
`51`	`55`	`warning: literal out of range for i8`
`52`		`- --> $DIR/type-overflow.rs:20:17`
	`56`	`+ --> $DIR/type-overflow.rs:21:17`
`53`	`57`	`\|`
`54`	`58`	`LL \| let fail = -0b1111_1111i8; //~WARNING literal out of range for i8`
`55`	`59`	\| ^^^^^^^^^^^^^ help: consider using `i16` instead: `0b1111_1111i16`