diff options
| author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-17 12:02:58 +0000 |
|---|---|---|
| committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-17 12:02:58 +0000 |
| commit | 698f8c2f01ea549d77d7dc3338a12e04c11057b9 (patch) | |
| tree | 173a775858bd501c378080a10dca74132f05bc50 /src/test/ui/numeric | |
| parent | Initial commit. (diff) | |
| download | rustc-698f8c2f01ea549d77d7dc3338a12e04c11057b9.tar.xz rustc-698f8c2f01ea549d77d7dc3338a12e04c11057b9.zip | |
Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/test/ui/numeric')
44 files changed, 11236 insertions, 0 deletions
diff --git a/src/test/ui/numeric/const-scope.rs b/src/test/ui/numeric/const-scope.rs new file mode 100644 index 000000000..053599a9b --- /dev/null +++ b/src/test/ui/numeric/const-scope.rs @@ -0,0 +1,12 @@ +const C: i32 = 1i8; //~ ERROR mismatched types +const D: i8 = C; //~ ERROR mismatched types + +const fn foo() { + let c: i32 = 1i8; //~ ERROR mismatched types + let d: i8 = c; //~ ERROR mismatched types +} + +fn main() { + let c: i32 = 1i8; //~ ERROR mismatched types + let d: i8 = c; //~ ERROR mismatched types +} diff --git a/src/test/ui/numeric/const-scope.stderr b/src/test/ui/numeric/const-scope.stderr new file mode 100644 index 000000000..4e4bcdf23 --- /dev/null +++ b/src/test/ui/numeric/const-scope.stderr @@ -0,0 +1,67 @@ +error[E0308]: mismatched types + --> $DIR/const-scope.rs:1:16 + | +LL | const C: i32 = 1i8; + | ^^^ expected `i32`, found `i8` + | +help: change the type of the numeric literal from `i8` to `i32` + | +LL | const C: i32 = 1i32; + | ~~~ + +error[E0308]: mismatched types + --> $DIR/const-scope.rs:2:15 + | +LL | const D: i8 = C; + | ^ expected `i8`, found `i32` + +error[E0308]: mismatched types + --> $DIR/const-scope.rs:5:18 + | +LL | let c: i32 = 1i8; + | --- ^^^ expected `i32`, found `i8` + | | + | expected due to this + | +help: change the type of the numeric literal from `i8` to `i32` + | +LL | let c: i32 = 1i32; + | ~~~ + +error[E0308]: mismatched types + --> $DIR/const-scope.rs:6:17 + | +LL | let d: i8 = c; + | -- ^ expected `i8`, found `i32` + | | + | expected due to this + +error[E0308]: mismatched types + --> $DIR/const-scope.rs:10:18 + | +LL | let c: i32 = 1i8; + | --- ^^^ expected `i32`, found `i8` + | | + | expected due to this + | +help: change the type of the numeric literal from `i8` to `i32` + | +LL | let c: i32 = 1i32; + | ~~~ + +error[E0308]: mismatched types + --> $DIR/const-scope.rs:11:17 + | +LL | let d: i8 = c; + | -- ^ expected `i8`, found `i32` + | | + | expected due to this + | +help: you can convert an `i32` to an `i8` and panic if the converted value doesn't fit + | +LL | let d: i8 = c.try_into().unwrap(); + | ++++++++++++++++++++ + +error: aborting due to 6 previous errors + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/numeric/integer-literal-suffix-inference.rs b/src/test/ui/numeric/integer-literal-suffix-inference.rs new file mode 100644 index 000000000..c320f2bb7 --- /dev/null +++ b/src/test/ui/numeric/integer-literal-suffix-inference.rs @@ -0,0 +1,220 @@ +fn main() { + + // the smallest positive values that need these types + let a8: i8 = 8; + let a16: i16 = 128; + let a32: i32 = 32_768; + let a64: i64 = 2_147_483_648; + + // the smallest negative values that need these types + let c8: i8 = -9; + let c16: i16 = -129; + let c32: i32 = -32_769; + let c64: i64 = -2_147_483_649; + + fn id_i8(n: i8) -> i8 { n } + fn id_i16(n: i16) -> i16 { n } + fn id_i32(n: i32) -> i32 { n } + fn id_i64(n: i64) -> i64 { n } + fn id_isize(n: isize) -> isize { n } + + // the smallest values that need these types + let b8: u8 = 16; + let b16: u16 = 256; + let b32: u32 = 65_536; + let b64: u64 = 4_294_967_296; + + fn id_u8(n: u8) -> u8 { n } + fn id_u16(n: u16) -> u16 { n } + fn id_u32(n: u32) -> u32 { n } + fn id_u64(n: u64) -> u64 { n } + fn id_usize(n: usize) -> usize { n } + + // Values for testing *size + let asize: isize = 1; + let bsize: usize = 3; + + id_i8(a8); // ok + id_i8(a16); + //~^ ERROR mismatched types + //~| expected `i8`, found `i16` + id_i8(a32); + //~^ ERROR mismatched types + //~| expected `i8`, found `i32` + id_i8(a64); + //~^ ERROR mismatched types + //~| expected `i8`, found `i64` + id_i8(asize); + //~^ ERROR mismatched types + //~| expected `i8`, found `isize` + + id_i16(a8); + //~^ ERROR mismatched types + //~| expected `i16`, found `i8` + id_i16(a16); // ok + id_i16(a32); + //~^ ERROR mismatched types + //~| expected `i16`, found `i32` + id_i16(a64); + //~^ ERROR mismatched types + //~| expected `i16`, found `i64` + id_i16(asize); + //~^ ERROR mismatched types + //~| expected `i16`, found `isize` + + id_i32(a8); + //~^ ERROR mismatched types + //~| expected `i32`, found `i8` + id_i32(a16); + //~^ ERROR mismatched types + //~| expected `i32`, found `i16` + id_i32(a32); // ok + id_i32(a64); + //~^ ERROR mismatched types + //~| expected `i32`, found `i64` + id_i32(asize); + //~^ ERROR mismatched types + //~| expected `i32`, found `isize` + + id_i64(a8); + //~^ ERROR mismatched types + //~| expected `i64`, found `i8` + id_i64(a16); + //~^ ERROR mismatched types + //~| expected `i64`, found `i16` + id_i64(a32); + //~^ ERROR mismatched types + //~| expected `i64`, found `i32` + id_i64(a64); // ok + id_i64(asize); + //~^ ERROR mismatched types + //~| expected `i64`, found `isize` + + id_isize(a8); + //~^ ERROR mismatched types + //~| expected `isize`, found `i8` + id_isize(a16); + //~^ ERROR mismatched types + //~| expected `isize`, found `i16` + id_isize(a32); + //~^ ERROR mismatched types + //~| expected `isize`, found `i32` + id_isize(a64); + //~^ ERROR mismatched types + //~| expected `isize`, found `i64` + id_isize(asize); //ok + + id_i8(c8); // ok + id_i8(c16); + //~^ ERROR mismatched types + //~| expected `i8`, found `i16` + id_i8(c32); + //~^ ERROR mismatched types + //~| expected `i8`, found `i32` + id_i8(c64); + //~^ ERROR mismatched types + //~| expected `i8`, found `i64` + + id_i16(c8); + //~^ ERROR mismatched types + //~| expected `i16`, found `i8` + id_i16(c16); // ok + id_i16(c32); + //~^ ERROR mismatched types + //~| expected `i16`, found `i32` + id_i16(c64); + //~^ ERROR mismatched types + //~| expected `i16`, found `i64` + + id_i32(c8); + //~^ ERROR mismatched types + //~| expected `i32`, found `i8` + id_i32(c16); + //~^ ERROR mismatched types + //~| expected `i32`, found `i16` + id_i32(c32); // ok + id_i32(c64); + //~^ ERROR mismatched types + //~| expected `i32`, found `i64` + + id_i64(a8); + //~^ ERROR mismatched types + //~| expected `i64`, found `i8` + id_i64(a16); + //~^ ERROR mismatched types + //~| expected `i64`, found `i16` + id_i64(a32); + //~^ ERROR mismatched types + //~| expected `i64`, found `i32` + id_i64(a64); // ok + + id_u8(b8); // ok + id_u8(b16); + //~^ ERROR mismatched types + //~| expected `u8`, found `u16` + id_u8(b32); + //~^ ERROR mismatched types + //~| expected `u8`, found `u32` + id_u8(b64); + //~^ ERROR mismatched types + //~| expected `u8`, found `u64` + id_u8(bsize); + //~^ ERROR mismatched types + //~| expected `u8`, found `usize` + + id_u16(b8); + //~^ ERROR mismatched types + //~| expected `u16`, found `u8` + id_u16(b16); // ok + id_u16(b32); + //~^ ERROR mismatched types + //~| expected `u16`, found `u32` + id_u16(b64); + //~^ ERROR mismatched types + //~| expected `u16`, found `u64` + id_u16(bsize); + //~^ ERROR mismatched types + //~| expected `u16`, found `usize` + + id_u32(b8); + //~^ ERROR mismatched types + //~| expected `u32`, found `u8` + id_u32(b16); + //~^ ERROR mismatched types + //~| expected `u32`, found `u16` + id_u32(b32); // ok + id_u32(b64); + //~^ ERROR mismatched types + //~| expected `u32`, found `u64` + id_u32(bsize); + //~^ ERROR mismatched types + //~| expected `u32`, found `usize` + + id_u64(b8); + //~^ ERROR mismatched types + //~| expected `u64`, found `u8` + id_u64(b16); + //~^ ERROR mismatched types + //~| expected `u64`, found `u16` + id_u64(b32); + //~^ ERROR mismatched types + //~| expected `u64`, found `u32` + id_u64(b64); // ok + id_u64(bsize); + //~^ ERROR mismatched types + //~| expected `u64`, found `usize` + + id_usize(b8); + //~^ ERROR mismatched types + //~| expected `usize`, found `u8` + id_usize(b16); + //~^ ERROR mismatched types + //~| expected `usize`, found `u16` + id_usize(b32); + //~^ ERROR mismatched types + //~| expected `usize`, found `u32` + id_usize(b64); + //~^ ERROR mismatched types + //~| expected `usize`, found `u64` + id_usize(bsize); //ok +} diff --git a/src/test/ui/numeric/integer-literal-suffix-inference.stderr b/src/test/ui/numeric/integer-literal-suffix-inference.stderr new file mode 100644 index 000000000..5045f584c --- /dev/null +++ b/src/test/ui/numeric/integer-literal-suffix-inference.stderr @@ -0,0 +1,939 @@ +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:38:11 + | +LL | id_i8(a16); + | ----- ^^^ expected `i8`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:15:8 + | +LL | fn id_i8(n: i8) -> i8 { n } + | ^^^^^ ----- +help: you can convert an `i16` to an `i8` and panic if the converted value doesn't fit + | +LL | id_i8(a16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:41:11 + | +LL | id_i8(a32); + | ----- ^^^ expected `i8`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:15:8 + | +LL | fn id_i8(n: i8) -> i8 { n } + | ^^^^^ ----- +help: you can convert an `i32` to an `i8` and panic if the converted value doesn't fit + | +LL | id_i8(a32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:44:11 + | +LL | id_i8(a64); + | ----- ^^^ expected `i8`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:15:8 + | +LL | fn id_i8(n: i8) -> i8 { n } + | ^^^^^ ----- +help: you can convert an `i64` to an `i8` and panic if the converted value doesn't fit + | +LL | id_i8(a64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:47:11 + | +LL | id_i8(asize); + | ----- ^^^^^ expected `i8`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:15:8 + | +LL | fn id_i8(n: i8) -> i8 { n } + | ^^^^^ ----- +help: you can convert an `isize` to an `i8` and panic if the converted value doesn't fit + | +LL | id_i8(asize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:51:12 + | +LL | id_i16(a8); + | ------ ^^ expected `i16`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:16:8 + | +LL | fn id_i16(n: i16) -> i16 { n } + | ^^^^^^ ------ +help: you can convert an `i8` to an `i16` + | +LL | id_i16(a8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:55:12 + | +LL | id_i16(a32); + | ------ ^^^ expected `i16`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:16:8 + | +LL | fn id_i16(n: i16) -> i16 { n } + | ^^^^^^ ------ +help: you can convert an `i32` to an `i16` and panic if the converted value doesn't fit + | +LL | id_i16(a32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:58:12 + | +LL | id_i16(a64); + | ------ ^^^ expected `i16`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:16:8 + | +LL | fn id_i16(n: i16) -> i16 { n } + | ^^^^^^ ------ +help: you can convert an `i64` to an `i16` and panic if the converted value doesn't fit + | +LL | id_i16(a64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:61:12 + | +LL | id_i16(asize); + | ------ ^^^^^ expected `i16`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:16:8 + | +LL | fn id_i16(n: i16) -> i16 { n } + | ^^^^^^ ------ +help: you can convert an `isize` to an `i16` and panic if the converted value doesn't fit + | +LL | id_i16(asize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:65:12 + | +LL | id_i32(a8); + | ------ ^^ expected `i32`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:17:8 + | +LL | fn id_i32(n: i32) -> i32 { n } + | ^^^^^^ ------ +help: you can convert an `i8` to an `i32` + | +LL | id_i32(a8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:68:12 + | +LL | id_i32(a16); + | ------ ^^^ expected `i32`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:17:8 + | +LL | fn id_i32(n: i32) -> i32 { n } + | ^^^^^^ ------ +help: you can convert an `i16` to an `i32` + | +LL | id_i32(a16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:72:12 + | +LL | id_i32(a64); + | ------ ^^^ expected `i32`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:17:8 + | +LL | fn id_i32(n: i32) -> i32 { n } + | ^^^^^^ ------ +help: you can convert an `i64` to an `i32` and panic if the converted value doesn't fit + | +LL | id_i32(a64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:75:12 + | +LL | id_i32(asize); + | ------ ^^^^^ expected `i32`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:17:8 + | +LL | fn id_i32(n: i32) -> i32 { n } + | ^^^^^^ ------ +help: you can convert an `isize` to an `i32` and panic if the converted value doesn't fit + | +LL | id_i32(asize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:79:12 + | +LL | id_i64(a8); + | ------ ^^ expected `i64`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:18:8 + | +LL | fn id_i64(n: i64) -> i64 { n } + | ^^^^^^ ------ +help: you can convert an `i8` to an `i64` + | +LL | id_i64(a8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:82:12 + | +LL | id_i64(a16); + | ------ ^^^ expected `i64`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:18:8 + | +LL | fn id_i64(n: i64) -> i64 { n } + | ^^^^^^ ------ +help: you can convert an `i16` to an `i64` + | +LL | id_i64(a16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:85:12 + | +LL | id_i64(a32); + | ------ ^^^ expected `i64`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:18:8 + | +LL | fn id_i64(n: i64) -> i64 { n } + | ^^^^^^ ------ +help: you can convert an `i32` to an `i64` + | +LL | id_i64(a32.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:89:12 + | +LL | id_i64(asize); + | ------ ^^^^^ expected `i64`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:18:8 + | +LL | fn id_i64(n: i64) -> i64 { n } + | ^^^^^^ ------ +help: you can convert an `isize` to an `i64` and panic if the converted value doesn't fit + | +LL | id_i64(asize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:93:14 + | +LL | id_isize(a8); + | -------- ^^ expected `isize`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:19:8 + | +LL | fn id_isize(n: isize) -> isize { n } + | ^^^^^^^^ -------- +help: you can convert an `i8` to an `isize` + | +LL | id_isize(a8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:96:14 + | +LL | id_isize(a16); + | -------- ^^^ expected `isize`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:19:8 + | +LL | fn id_isize(n: isize) -> isize { n } + | ^^^^^^^^ -------- +help: you can convert an `i16` to an `isize` + | +LL | id_isize(a16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:99:14 + | +LL | id_isize(a32); + | -------- ^^^ expected `isize`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:19:8 + | +LL | fn id_isize(n: isize) -> isize { n } + | ^^^^^^^^ -------- +help: you can convert an `i32` to an `isize` and panic if the converted value doesn't fit + | +LL | id_isize(a32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:102:14 + | +LL | id_isize(a64); + | -------- ^^^ expected `isize`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:19:8 + | +LL | fn id_isize(n: isize) -> isize { n } + | ^^^^^^^^ -------- +help: you can convert an `i64` to an `isize` and panic if the converted value doesn't fit + | +LL | id_isize(a64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:108:11 + | +LL | id_i8(c16); + | ----- ^^^ expected `i8`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:15:8 + | +LL | fn id_i8(n: i8) -> i8 { n } + | ^^^^^ ----- +help: you can convert an `i16` to an `i8` and panic if the converted value doesn't fit + | +LL | id_i8(c16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:111:11 + | +LL | id_i8(c32); + | ----- ^^^ expected `i8`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:15:8 + | +LL | fn id_i8(n: i8) -> i8 { n } + | ^^^^^ ----- +help: you can convert an `i32` to an `i8` and panic if the converted value doesn't fit + | +LL | id_i8(c32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:114:11 + | +LL | id_i8(c64); + | ----- ^^^ expected `i8`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:15:8 + | +LL | fn id_i8(n: i8) -> i8 { n } + | ^^^^^ ----- +help: you can convert an `i64` to an `i8` and panic if the converted value doesn't fit + | +LL | id_i8(c64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:118:12 + | +LL | id_i16(c8); + | ------ ^^ expected `i16`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:16:8 + | +LL | fn id_i16(n: i16) -> i16 { n } + | ^^^^^^ ------ +help: you can convert an `i8` to an `i16` + | +LL | id_i16(c8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:122:12 + | +LL | id_i16(c32); + | ------ ^^^ expected `i16`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:16:8 + | +LL | fn id_i16(n: i16) -> i16 { n } + | ^^^^^^ ------ +help: you can convert an `i32` to an `i16` and panic if the converted value doesn't fit + | +LL | id_i16(c32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:125:12 + | +LL | id_i16(c64); + | ------ ^^^ expected `i16`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:16:8 + | +LL | fn id_i16(n: i16) -> i16 { n } + | ^^^^^^ ------ +help: you can convert an `i64` to an `i16` and panic if the converted value doesn't fit + | +LL | id_i16(c64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:129:12 + | +LL | id_i32(c8); + | ------ ^^ expected `i32`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:17:8 + | +LL | fn id_i32(n: i32) -> i32 { n } + | ^^^^^^ ------ +help: you can convert an `i8` to an `i32` + | +LL | id_i32(c8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:132:12 + | +LL | id_i32(c16); + | ------ ^^^ expected `i32`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:17:8 + | +LL | fn id_i32(n: i32) -> i32 { n } + | ^^^^^^ ------ +help: you can convert an `i16` to an `i32` + | +LL | id_i32(c16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:136:12 + | +LL | id_i32(c64); + | ------ ^^^ expected `i32`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:17:8 + | +LL | fn id_i32(n: i32) -> i32 { n } + | ^^^^^^ ------ +help: you can convert an `i64` to an `i32` and panic if the converted value doesn't fit + | +LL | id_i32(c64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:140:12 + | +LL | id_i64(a8); + | ------ ^^ expected `i64`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:18:8 + | +LL | fn id_i64(n: i64) -> i64 { n } + | ^^^^^^ ------ +help: you can convert an `i8` to an `i64` + | +LL | id_i64(a8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:143:12 + | +LL | id_i64(a16); + | ------ ^^^ expected `i64`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:18:8 + | +LL | fn id_i64(n: i64) -> i64 { n } + | ^^^^^^ ------ +help: you can convert an `i16` to an `i64` + | +LL | id_i64(a16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:146:12 + | +LL | id_i64(a32); + | ------ ^^^ expected `i64`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:18:8 + | +LL | fn id_i64(n: i64) -> i64 { n } + | ^^^^^^ ------ +help: you can convert an `i32` to an `i64` + | +LL | id_i64(a32.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:152:11 + | +LL | id_u8(b16); + | ----- ^^^ expected `u8`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:27:8 + | +LL | fn id_u8(n: u8) -> u8 { n } + | ^^^^^ ----- +help: you can convert a `u16` to a `u8` and panic if the converted value doesn't fit + | +LL | id_u8(b16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:155:11 + | +LL | id_u8(b32); + | ----- ^^^ expected `u8`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:27:8 + | +LL | fn id_u8(n: u8) -> u8 { n } + | ^^^^^ ----- +help: you can convert a `u32` to a `u8` and panic if the converted value doesn't fit + | +LL | id_u8(b32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:158:11 + | +LL | id_u8(b64); + | ----- ^^^ expected `u8`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:27:8 + | +LL | fn id_u8(n: u8) -> u8 { n } + | ^^^^^ ----- +help: you can convert a `u64` to a `u8` and panic if the converted value doesn't fit + | +LL | id_u8(b64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:161:11 + | +LL | id_u8(bsize); + | ----- ^^^^^ expected `u8`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:27:8 + | +LL | fn id_u8(n: u8) -> u8 { n } + | ^^^^^ ----- +help: you can convert a `usize` to a `u8` and panic if the converted value doesn't fit + | +LL | id_u8(bsize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:165:12 + | +LL | id_u16(b8); + | ------ ^^ expected `u16`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:28:8 + | +LL | fn id_u16(n: u16) -> u16 { n } + | ^^^^^^ ------ +help: you can convert a `u8` to a `u16` + | +LL | id_u16(b8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:169:12 + | +LL | id_u16(b32); + | ------ ^^^ expected `u16`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:28:8 + | +LL | fn id_u16(n: u16) -> u16 { n } + | ^^^^^^ ------ +help: you can convert a `u32` to a `u16` and panic if the converted value doesn't fit + | +LL | id_u16(b32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:172:12 + | +LL | id_u16(b64); + | ------ ^^^ expected `u16`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:28:8 + | +LL | fn id_u16(n: u16) -> u16 { n } + | ^^^^^^ ------ +help: you can convert a `u64` to a `u16` and panic if the converted value doesn't fit + | +LL | id_u16(b64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:175:12 + | +LL | id_u16(bsize); + | ------ ^^^^^ expected `u16`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:28:8 + | +LL | fn id_u16(n: u16) -> u16 { n } + | ^^^^^^ ------ +help: you can convert a `usize` to a `u16` and panic if the converted value doesn't fit + | +LL | id_u16(bsize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:179:12 + | +LL | id_u32(b8); + | ------ ^^ expected `u32`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:29:8 + | +LL | fn id_u32(n: u32) -> u32 { n } + | ^^^^^^ ------ +help: you can convert a `u8` to a `u32` + | +LL | id_u32(b8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:182:12 + | +LL | id_u32(b16); + | ------ ^^^ expected `u32`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:29:8 + | +LL | fn id_u32(n: u32) -> u32 { n } + | ^^^^^^ ------ +help: you can convert a `u16` to a `u32` + | +LL | id_u32(b16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:186:12 + | +LL | id_u32(b64); + | ------ ^^^ expected `u32`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:29:8 + | +LL | fn id_u32(n: u32) -> u32 { n } + | ^^^^^^ ------ +help: you can convert a `u64` to a `u32` and panic if the converted value doesn't fit + | +LL | id_u32(b64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:189:12 + | +LL | id_u32(bsize); + | ------ ^^^^^ expected `u32`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:29:8 + | +LL | fn id_u32(n: u32) -> u32 { n } + | ^^^^^^ ------ +help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit + | +LL | id_u32(bsize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:193:12 + | +LL | id_u64(b8); + | ------ ^^ expected `u64`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:30:8 + | +LL | fn id_u64(n: u64) -> u64 { n } + | ^^^^^^ ------ +help: you can convert a `u8` to a `u64` + | +LL | id_u64(b8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:196:12 + | +LL | id_u64(b16); + | ------ ^^^ expected `u64`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:30:8 + | +LL | fn id_u64(n: u64) -> u64 { n } + | ^^^^^^ ------ +help: you can convert a `u16` to a `u64` + | +LL | id_u64(b16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:199:12 + | +LL | id_u64(b32); + | ------ ^^^ expected `u64`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:30:8 + | +LL | fn id_u64(n: u64) -> u64 { n } + | ^^^^^^ ------ +help: you can convert a `u32` to a `u64` + | +LL | id_u64(b32.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:203:12 + | +LL | id_u64(bsize); + | ------ ^^^^^ expected `u64`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:30:8 + | +LL | fn id_u64(n: u64) -> u64 { n } + | ^^^^^^ ------ +help: you can convert a `usize` to a `u64` and panic if the converted value doesn't fit + | +LL | id_u64(bsize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:207:14 + | +LL | id_usize(b8); + | -------- ^^ expected `usize`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:31:8 + | +LL | fn id_usize(n: usize) -> usize { n } + | ^^^^^^^^ -------- +help: you can convert a `u8` to a `usize` + | +LL | id_usize(b8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:210:14 + | +LL | id_usize(b16); + | -------- ^^^ expected `usize`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:31:8 + | +LL | fn id_usize(n: usize) -> usize { n } + | ^^^^^^^^ -------- +help: you can convert a `u16` to a `usize` + | +LL | id_usize(b16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:213:14 + | +LL | id_usize(b32); + | -------- ^^^ expected `usize`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:31:8 + | +LL | fn id_usize(n: usize) -> usize { n } + | ^^^^^^^^ -------- +help: you can convert a `u32` to a `usize` and panic if the converted value doesn't fit + | +LL | id_usize(b32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/integer-literal-suffix-inference.rs:216:14 + | +LL | id_usize(b64); + | -------- ^^^ expected `usize`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/integer-literal-suffix-inference.rs:31:8 + | +LL | fn id_usize(n: usize) -> usize { n } + | ^^^^^^^^ -------- +help: you can convert a `u64` to a `usize` and panic if the converted value doesn't fit + | +LL | id_usize(b64.try_into().unwrap()); + | ++++++++++++++++++++ + +error: aborting due to 52 previous errors + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/numeric/len.rs b/src/test/ui/numeric/len.rs new file mode 100644 index 000000000..a72540988 --- /dev/null +++ b/src/test/ui/numeric/len.rs @@ -0,0 +1,8 @@ +fn main() { + let array = [1, 2, 3]; + test(array.len()); //~ ERROR mismatched types +} + +fn test(length: u32) { + println!("{}", length); +} diff --git a/src/test/ui/numeric/len.stderr b/src/test/ui/numeric/len.stderr new file mode 100644 index 000000000..55a61b5e4 --- /dev/null +++ b/src/test/ui/numeric/len.stderr @@ -0,0 +1,21 @@ +error[E0308]: mismatched types + --> $DIR/len.rs:3:10 + | +LL | test(array.len()); + | ---- ^^^^^^^^^^^ expected `u32`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/len.rs:6:4 + | +LL | fn test(length: u32) { + | ^^^^ ----------- +help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit + | +LL | test(array.len().try_into().unwrap()); + | ++++++++++++++++++++ + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/numeric/numeric-cast-2.rs b/src/test/ui/numeric/numeric-cast-2.rs new file mode 100644 index 000000000..ad2de5d2b --- /dev/null +++ b/src/test/ui/numeric/numeric-cast-2.rs @@ -0,0 +1,11 @@ +fn foo() -> i32 { + 4 +} +fn main() { + let x: u16 = foo(); + //~^ ERROR mismatched types + let y: i64 = x + x; + //~^ ERROR mismatched types + let z: i32 = x + x; + //~^ ERROR mismatched types +} diff --git a/src/test/ui/numeric/numeric-cast-2.stderr b/src/test/ui/numeric/numeric-cast-2.stderr new file mode 100644 index 000000000..a7b342739 --- /dev/null +++ b/src/test/ui/numeric/numeric-cast-2.stderr @@ -0,0 +1,42 @@ +error[E0308]: mismatched types + --> $DIR/numeric-cast-2.rs:5:18 + | +LL | let x: u16 = foo(); + | --- ^^^^^ expected `u16`, found `i32` + | | + | expected due to this + | +help: you can convert an `i32` to a `u16` and panic if the converted value doesn't fit + | +LL | let x: u16 = foo().try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-2.rs:7:18 + | +LL | let y: i64 = x + x; + | --- ^^^^^ expected `i64`, found `u16` + | | + | expected due to this + | +help: you can convert a `u16` to an `i64` + | +LL | let y: i64 = (x + x).into(); + | + ++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-2.rs:9:18 + | +LL | let z: i32 = x + x; + | --- ^^^^^ expected `i32`, found `u16` + | | + | expected due to this + | +help: you can convert a `u16` to an `i32` + | +LL | let z: i32 = (x + x).into(); + | + ++++++++ + +error: aborting due to 3 previous errors + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/numeric/numeric-cast-binop.fixed b/src/test/ui/numeric/numeric-cast-binop.fixed new file mode 100644 index 000000000..edb085e71 --- /dev/null +++ b/src/test/ui/numeric/numeric-cast-binop.fixed @@ -0,0 +1,320 @@ +// run-rustfix + +// The `try_into` suggestion doesn't include this, but we do suggest it after applying it +use std::convert::TryInto; + +#[allow(unused_must_use)] +fn main() { + let x_usize: usize = 1; + let x_u128: u128 = 2; + let x_u64: u64 = 3; + let x_u32: u32 = 4; + let x_u16: u16 = 5; + let x_u8: u8 = 6; + let x_isize: isize = 7; + let x_i64: i64 = 8; + let x_i32: i32 = 9; + let x_i16: i16 = 10; + let x_i8: i8 = 11; + let x_i128: i128 = 12; + + /* u<->u */ + { + u16::from(x_u8) > x_u16; + //~^ ERROR mismatched types + u32::from(x_u8) > x_u32; + //~^ ERROR mismatched types + u64::from(x_u8) > x_u64; + //~^ ERROR mismatched types + u128::from(x_u8) > x_u128; + //~^ ERROR mismatched types + usize::from(x_u8) > x_usize; + //~^ ERROR mismatched types + + x_u16 > x_u8.into(); + //~^ ERROR mismatched types + u32::from(x_u16) > x_u32; + //~^ ERROR mismatched types + u64::from(x_u16) > x_u64; + //~^ ERROR mismatched types + u128::from(x_u16) > x_u128; + //~^ ERROR mismatched types + usize::from(x_u16) > x_usize; + //~^ ERROR mismatched types + + x_u32 > x_u8.into(); + //~^ ERROR mismatched types + x_u32 > x_u16.into(); + //~^ ERROR mismatched types + u64::from(x_u32) > x_u64; + //~^ ERROR mismatched types + u128::from(x_u32) > x_u128; + //~^ ERROR mismatched types + x_u32 > x_usize.try_into().unwrap(); + //~^ ERROR mismatched types + + x_u64 > x_u8.into(); + //~^ ERROR mismatched types + x_u64 > x_u16.into(); + //~^ ERROR mismatched types + x_u64 > x_u32.into(); + //~^ ERROR mismatched types + u128::from(x_u64) > x_u128; + //~^ ERROR mismatched types + x_u64 > x_usize.try_into().unwrap(); + //~^ ERROR mismatched types + + x_u128 > x_u8.into(); + //~^ ERROR mismatched types + x_u128 > x_u16.into(); + //~^ ERROR mismatched types + x_u128 > x_u32.into(); + //~^ ERROR mismatched types + x_u128 > x_u64.into(); + //~^ ERROR mismatched types + x_u128 > x_usize.try_into().unwrap(); + //~^ ERROR mismatched types + + x_usize > x_u8.into(); + //~^ ERROR mismatched types + x_usize > x_u16.into(); + //~^ ERROR mismatched types + x_usize > x_u32.try_into().unwrap(); + //~^ ERROR mismatched types + x_usize > x_u64.try_into().unwrap(); + //~^ ERROR mismatched types + x_usize > x_u128.try_into().unwrap(); + //~^ ERROR mismatched types + } + + /* i<->i */ + { + i16::from(x_i8) > x_i16; + //~^ ERROR mismatched types + i32::from(x_i8) > x_i32; + //~^ ERROR mismatched types + i64::from(x_i8) > x_i64; + //~^ ERROR mismatched types + i128::from(x_i8) > x_i128; + //~^ ERROR mismatched types + isize::from(x_i8) > x_isize; + //~^ ERROR mismatched types + + x_i16 > x_i8.into(); + //~^ ERROR mismatched types + i32::from(x_i16) > x_i32; + //~^ ERROR mismatched types + i64::from(x_i16) > x_i64; + //~^ ERROR mismatched types + i128::from(x_i16) > x_i128; + //~^ ERROR mismatched types + isize::from(x_i16) > x_isize; + //~^ ERROR mismatched types + + x_i32 > x_i8.into(); + //~^ ERROR mismatched types + x_i32 > x_i16.into(); + //~^ ERROR mismatched types + i64::from(x_i32) > x_i64; + //~^ ERROR mismatched types + i128::from(x_i32) > x_i128; + //~^ ERROR mismatched types + x_i32 > x_isize.try_into().unwrap(); + //~^ ERROR mismatched types + + x_i64 > x_i8.into(); + //~^ ERROR mismatched types + x_i64 > x_i16.into(); + //~^ ERROR mismatched types + x_i64 > x_i32.into(); + //~^ ERROR mismatched types + i128::from(x_i64) > x_i128; + //~^ ERROR mismatched types + x_i64 > x_isize.try_into().unwrap(); + //~^ ERROR mismatched types + + x_i128 > x_i8.into(); + //~^ ERROR mismatched types + x_i128 > x_i16.into(); + //~^ ERROR mismatched types + x_i128 > x_i32.into(); + //~^ ERROR mismatched types + x_i128 > x_i64.into(); + //~^ ERROR mismatched types + x_i128 > x_isize.try_into().unwrap(); + //~^ ERROR mismatched types + + x_isize > x_i8.into(); + //~^ ERROR mismatched types + x_isize > x_i16.into(); + //~^ ERROR mismatched types + x_isize > x_i32.try_into().unwrap(); + //~^ ERROR mismatched types + x_isize > x_i64.try_into().unwrap(); + //~^ ERROR mismatched types + x_isize > x_i128.try_into().unwrap(); + //~^ ERROR mismatched types + } + + /* u<->i */ + { + x_u8 > x_i8.try_into().unwrap(); + //~^ ERROR mismatched types + i16::from(x_u8) > x_i16; + //~^ ERROR mismatched types + i32::from(x_u8) > x_i32; + //~^ ERROR mismatched types + i64::from(x_u8) > x_i64; + //~^ ERROR mismatched types + i128::from(x_u8) > x_i128; + //~^ ERROR mismatched types + isize::from(x_u8) > x_isize; + //~^ ERROR mismatched types + + x_u16 > x_i8.try_into().unwrap(); + //~^ ERROR mismatched types + x_u16 > x_i16.try_into().unwrap(); + //~^ ERROR mismatched types + i32::from(x_u16) > x_i32; + //~^ ERROR mismatched types + i64::from(x_u16) > x_i64; + //~^ ERROR mismatched types + i128::from(x_u16) > x_i128; + //~^ ERROR mismatched types + x_u16 > x_isize.try_into().unwrap(); + //~^ ERROR mismatched types + + x_u32 > x_i8.try_into().unwrap(); + //~^ ERROR mismatched types + x_u32 > x_i16.try_into().unwrap(); + //~^ ERROR mismatched types + x_u32 > x_i32.try_into().unwrap(); + //~^ ERROR mismatched types + i64::from(x_u32) > x_i64; + //~^ ERROR mismatched types + i128::from(x_u32) > x_i128; + //~^ ERROR mismatched types + x_u32 > x_isize.try_into().unwrap(); + //~^ ERROR mismatched types + + x_u64 > x_i8.try_into().unwrap(); + //~^ ERROR mismatched types + x_u64 > x_i16.try_into().unwrap(); + //~^ ERROR mismatched types + x_u64 > x_i32.try_into().unwrap(); + //~^ ERROR mismatched types + x_u64 > x_i64.try_into().unwrap(); + //~^ ERROR mismatched types + i128::from(x_u64) > x_i128; + //~^ ERROR mismatched types + x_u64 > x_isize.try_into().unwrap(); + //~^ ERROR mismatched types + + x_u128 > x_i8.try_into().unwrap(); + //~^ ERROR mismatched types + x_u128 > x_i16.try_into().unwrap(); + //~^ ERROR mismatched types + x_u128 > x_i32.try_into().unwrap(); + //~^ ERROR mismatched types + x_u128 > x_i64.try_into().unwrap(); + //~^ ERROR mismatched types + x_u128 > x_i128.try_into().unwrap(); + //~^ ERROR mismatched types + x_u128 > x_isize.try_into().unwrap(); + //~^ ERROR mismatched types + + x_usize > x_i8.try_into().unwrap(); + //~^ ERROR mismatched types + x_usize > x_i16.try_into().unwrap(); + //~^ ERROR mismatched types + x_usize > x_i32.try_into().unwrap(); + //~^ ERROR mismatched types + x_usize > x_i64.try_into().unwrap(); + //~^ ERROR mismatched types + x_usize > x_i128.try_into().unwrap(); + //~^ ERROR mismatched types + x_usize > x_isize.try_into().unwrap(); + //~^ ERROR mismatched types + } + + /* i<->u */ + { + x_i8 > x_u8.try_into().unwrap(); + //~^ ERROR mismatched types + x_i8 > x_u16.try_into().unwrap(); + //~^ ERROR mismatched types + x_i8 > x_u32.try_into().unwrap(); + //~^ ERROR mismatched types + x_i8 > x_u64.try_into().unwrap(); + //~^ ERROR mismatched types + x_i8 > x_u128.try_into().unwrap(); + //~^ ERROR mismatched types + x_i8 > x_usize.try_into().unwrap(); + //~^ ERROR mismatched types + + x_i16 > x_u8.into(); + //~^ ERROR mismatched types + x_i16 > x_u16.try_into().unwrap(); + //~^ ERROR mismatched types + x_i16 > x_u32.try_into().unwrap(); + //~^ ERROR mismatched types + x_i16 > x_u64.try_into().unwrap(); + //~^ ERROR mismatched types + x_i16 > x_u128.try_into().unwrap(); + //~^ ERROR mismatched types + x_i16 > x_usize.try_into().unwrap(); + //~^ ERROR mismatched types + + x_i32 > x_u8.into(); + //~^ ERROR mismatched types + x_i32 > x_u16.into(); + //~^ ERROR mismatched types + x_i32 > x_u32.try_into().unwrap(); + //~^ ERROR mismatched types + x_i32 > x_u64.try_into().unwrap(); + //~^ ERROR mismatched types + x_i32 > x_u128.try_into().unwrap(); + //~^ ERROR mismatched types + x_i32 > x_usize.try_into().unwrap(); + //~^ ERROR mismatched types + + x_i64 > x_u8.into(); + //~^ ERROR mismatched types + x_i64 > x_u16.into(); + //~^ ERROR mismatched types + x_i64 > x_u32.into(); + //~^ ERROR mismatched types + x_i64 > x_u64.try_into().unwrap(); + //~^ ERROR mismatched types + x_i64 > x_u128.try_into().unwrap(); + //~^ ERROR mismatched types + x_i64 > x_usize.try_into().unwrap(); + //~^ ERROR mismatched types + + x_i128 > x_u8.into(); + //~^ ERROR mismatched types + x_i128 > x_u16.into(); + //~^ ERROR mismatched types + x_i128 > x_u32.into(); + //~^ ERROR mismatched types + x_i128 > x_u64.into(); + //~^ ERROR mismatched types + x_i128 > x_u128.try_into().unwrap(); + //~^ ERROR mismatched types + x_i128 > x_usize.try_into().unwrap(); + //~^ ERROR mismatched types + + x_isize > x_u8.into(); + //~^ ERROR mismatched types + x_isize > x_u16.try_into().unwrap(); + //~^ ERROR mismatched types + x_isize > x_u32.try_into().unwrap(); + //~^ ERROR mismatched types + x_isize > x_u64.try_into().unwrap(); + //~^ ERROR mismatched types + x_isize > x_u128.try_into().unwrap(); + //~^ ERROR mismatched types + x_isize > x_usize.try_into().unwrap(); + //~^ ERROR mismatched types + } +} diff --git a/src/test/ui/numeric/numeric-cast-binop.rs b/src/test/ui/numeric/numeric-cast-binop.rs new file mode 100644 index 000000000..c1ed8de8a --- /dev/null +++ b/src/test/ui/numeric/numeric-cast-binop.rs @@ -0,0 +1,320 @@ +// run-rustfix + +// The `try_into` suggestion doesn't include this, but we do suggest it after applying it +use std::convert::TryInto; + +#[allow(unused_must_use)] +fn main() { + let x_usize: usize = 1; + let x_u128: u128 = 2; + let x_u64: u64 = 3; + let x_u32: u32 = 4; + let x_u16: u16 = 5; + let x_u8: u8 = 6; + let x_isize: isize = 7; + let x_i64: i64 = 8; + let x_i32: i32 = 9; + let x_i16: i16 = 10; + let x_i8: i8 = 11; + let x_i128: i128 = 12; + + /* u<->u */ + { + x_u8 > x_u16; + //~^ ERROR mismatched types + x_u8 > x_u32; + //~^ ERROR mismatched types + x_u8 > x_u64; + //~^ ERROR mismatched types + x_u8 > x_u128; + //~^ ERROR mismatched types + x_u8 > x_usize; + //~^ ERROR mismatched types + + x_u16 > x_u8; + //~^ ERROR mismatched types + x_u16 > x_u32; + //~^ ERROR mismatched types + x_u16 > x_u64; + //~^ ERROR mismatched types + x_u16 > x_u128; + //~^ ERROR mismatched types + x_u16 > x_usize; + //~^ ERROR mismatched types + + x_u32 > x_u8; + //~^ ERROR mismatched types + x_u32 > x_u16; + //~^ ERROR mismatched types + x_u32 > x_u64; + //~^ ERROR mismatched types + x_u32 > x_u128; + //~^ ERROR mismatched types + x_u32 > x_usize; + //~^ ERROR mismatched types + + x_u64 > x_u8; + //~^ ERROR mismatched types + x_u64 > x_u16; + //~^ ERROR mismatched types + x_u64 > x_u32; + //~^ ERROR mismatched types + x_u64 > x_u128; + //~^ ERROR mismatched types + x_u64 > x_usize; + //~^ ERROR mismatched types + + x_u128 > x_u8; + //~^ ERROR mismatched types + x_u128 > x_u16; + //~^ ERROR mismatched types + x_u128 > x_u32; + //~^ ERROR mismatched types + x_u128 > x_u64; + //~^ ERROR mismatched types + x_u128 > x_usize; + //~^ ERROR mismatched types + + x_usize > x_u8; + //~^ ERROR mismatched types + x_usize > x_u16; + //~^ ERROR mismatched types + x_usize > x_u32; + //~^ ERROR mismatched types + x_usize > x_u64; + //~^ ERROR mismatched types + x_usize > x_u128; + //~^ ERROR mismatched types + } + + /* i<->i */ + { + x_i8 > x_i16; + //~^ ERROR mismatched types + x_i8 > x_i32; + //~^ ERROR mismatched types + x_i8 > x_i64; + //~^ ERROR mismatched types + x_i8 > x_i128; + //~^ ERROR mismatched types + x_i8 > x_isize; + //~^ ERROR mismatched types + + x_i16 > x_i8; + //~^ ERROR mismatched types + x_i16 > x_i32; + //~^ ERROR mismatched types + x_i16 > x_i64; + //~^ ERROR mismatched types + x_i16 > x_i128; + //~^ ERROR mismatched types + x_i16 > x_isize; + //~^ ERROR mismatched types + + x_i32 > x_i8; + //~^ ERROR mismatched types + x_i32 > x_i16; + //~^ ERROR mismatched types + x_i32 > x_i64; + //~^ ERROR mismatched types + x_i32 > x_i128; + //~^ ERROR mismatched types + x_i32 > x_isize; + //~^ ERROR mismatched types + + x_i64 > x_i8; + //~^ ERROR mismatched types + x_i64 > x_i16; + //~^ ERROR mismatched types + x_i64 > x_i32; + //~^ ERROR mismatched types + x_i64 > x_i128; + //~^ ERROR mismatched types + x_i64 > x_isize; + //~^ ERROR mismatched types + + x_i128 > x_i8; + //~^ ERROR mismatched types + x_i128 > x_i16; + //~^ ERROR mismatched types + x_i128 > x_i32; + //~^ ERROR mismatched types + x_i128 > x_i64; + //~^ ERROR mismatched types + x_i128 > x_isize; + //~^ ERROR mismatched types + + x_isize > x_i8; + //~^ ERROR mismatched types + x_isize > x_i16; + //~^ ERROR mismatched types + x_isize > x_i32; + //~^ ERROR mismatched types + x_isize > x_i64; + //~^ ERROR mismatched types + x_isize > x_i128; + //~^ ERROR mismatched types + } + + /* u<->i */ + { + x_u8 > x_i8; + //~^ ERROR mismatched types + x_u8 > x_i16; + //~^ ERROR mismatched types + x_u8 > x_i32; + //~^ ERROR mismatched types + x_u8 > x_i64; + //~^ ERROR mismatched types + x_u8 > x_i128; + //~^ ERROR mismatched types + x_u8 > x_isize; + //~^ ERROR mismatched types + + x_u16 > x_i8; + //~^ ERROR mismatched types + x_u16 > x_i16; + //~^ ERROR mismatched types + x_u16 > x_i32; + //~^ ERROR mismatched types + x_u16 > x_i64; + //~^ ERROR mismatched types + x_u16 > x_i128; + //~^ ERROR mismatched types + x_u16 > x_isize; + //~^ ERROR mismatched types + + x_u32 > x_i8; + //~^ ERROR mismatched types + x_u32 > x_i16; + //~^ ERROR mismatched types + x_u32 > x_i32; + //~^ ERROR mismatched types + x_u32 > x_i64; + //~^ ERROR mismatched types + x_u32 > x_i128; + //~^ ERROR mismatched types + x_u32 > x_isize; + //~^ ERROR mismatched types + + x_u64 > x_i8; + //~^ ERROR mismatched types + x_u64 > x_i16; + //~^ ERROR mismatched types + x_u64 > x_i32; + //~^ ERROR mismatched types + x_u64 > x_i64; + //~^ ERROR mismatched types + x_u64 > x_i128; + //~^ ERROR mismatched types + x_u64 > x_isize; + //~^ ERROR mismatched types + + x_u128 > x_i8; + //~^ ERROR mismatched types + x_u128 > x_i16; + //~^ ERROR mismatched types + x_u128 > x_i32; + //~^ ERROR mismatched types + x_u128 > x_i64; + //~^ ERROR mismatched types + x_u128 > x_i128; + //~^ ERROR mismatched types + x_u128 > x_isize; + //~^ ERROR mismatched types + + x_usize > x_i8; + //~^ ERROR mismatched types + x_usize > x_i16; + //~^ ERROR mismatched types + x_usize > x_i32; + //~^ ERROR mismatched types + x_usize > x_i64; + //~^ ERROR mismatched types + x_usize > x_i128; + //~^ ERROR mismatched types + x_usize > x_isize; + //~^ ERROR mismatched types + } + + /* i<->u */ + { + x_i8 > x_u8; + //~^ ERROR mismatched types + x_i8 > x_u16; + //~^ ERROR mismatched types + x_i8 > x_u32; + //~^ ERROR mismatched types + x_i8 > x_u64; + //~^ ERROR mismatched types + x_i8 > x_u128; + //~^ ERROR mismatched types + x_i8 > x_usize; + //~^ ERROR mismatched types + + x_i16 > x_u8; + //~^ ERROR mismatched types + x_i16 > x_u16; + //~^ ERROR mismatched types + x_i16 > x_u32; + //~^ ERROR mismatched types + x_i16 > x_u64; + //~^ ERROR mismatched types + x_i16 > x_u128; + //~^ ERROR mismatched types + x_i16 > x_usize; + //~^ ERROR mismatched types + + x_i32 > x_u8; + //~^ ERROR mismatched types + x_i32 > x_u16; + //~^ ERROR mismatched types + x_i32 > x_u32; + //~^ ERROR mismatched types + x_i32 > x_u64; + //~^ ERROR mismatched types + x_i32 > x_u128; + //~^ ERROR mismatched types + x_i32 > x_usize; + //~^ ERROR mismatched types + + x_i64 > x_u8; + //~^ ERROR mismatched types + x_i64 > x_u16; + //~^ ERROR mismatched types + x_i64 > x_u32; + //~^ ERROR mismatched types + x_i64 > x_u64; + //~^ ERROR mismatched types + x_i64 > x_u128; + //~^ ERROR mismatched types + x_i64 > x_usize; + //~^ ERROR mismatched types + + x_i128 > x_u8; + //~^ ERROR mismatched types + x_i128 > x_u16; + //~^ ERROR mismatched types + x_i128 > x_u32; + //~^ ERROR mismatched types + x_i128 > x_u64; + //~^ ERROR mismatched types + x_i128 > x_u128; + //~^ ERROR mismatched types + x_i128 > x_usize; + //~^ ERROR mismatched types + + x_isize > x_u8; + //~^ ERROR mismatched types + x_isize > x_u16; + //~^ ERROR mismatched types + x_isize > x_u32; + //~^ ERROR mismatched types + x_isize > x_u64; + //~^ ERROR mismatched types + x_isize > x_u128; + //~^ ERROR mismatched types + x_isize > x_usize; + //~^ ERROR mismatched types + } +} diff --git a/src/test/ui/numeric/numeric-cast-binop.stderr b/src/test/ui/numeric/numeric-cast-binop.stderr new file mode 100644 index 000000000..2f58f1649 --- /dev/null +++ b/src/test/ui/numeric/numeric-cast-binop.stderr @@ -0,0 +1,1455 @@ +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:23:16 + | +LL | x_u8 > x_u16; + | ^^^^^ expected `u8`, found `u16` + | +help: you can convert `x_u8` from `u8` to `u16`, matching the type of `x_u16` + | +LL | u16::from(x_u8) > x_u16; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:25:16 + | +LL | x_u8 > x_u32; + | ^^^^^ expected `u8`, found `u32` + | +help: you can convert `x_u8` from `u8` to `u32`, matching the type of `x_u32` + | +LL | u32::from(x_u8) > x_u32; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:27:16 + | +LL | x_u8 > x_u64; + | ^^^^^ expected `u8`, found `u64` + | +help: you can convert `x_u8` from `u8` to `u64`, matching the type of `x_u64` + | +LL | u64::from(x_u8) > x_u64; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:29:16 + | +LL | x_u8 > x_u128; + | ^^^^^^ expected `u8`, found `u128` + | +help: you can convert `x_u8` from `u8` to `u128`, matching the type of `x_u128` + | +LL | u128::from(x_u8) > x_u128; + | +++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:31:16 + | +LL | x_u8 > x_usize; + | ^^^^^^^ expected `u8`, found `usize` + | +help: you can convert `x_u8` from `u8` to `usize`, matching the type of `x_usize` + | +LL | usize::from(x_u8) > x_usize; + | ++++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:34:17 + | +LL | x_u16 > x_u8; + | ^^^^ expected `u16`, found `u8` + | +help: you can convert a `u8` to a `u16` + | +LL | x_u16 > x_u8.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:36:17 + | +LL | x_u16 > x_u32; + | ^^^^^ expected `u16`, found `u32` + | +help: you can convert `x_u16` from `u16` to `u32`, matching the type of `x_u32` + | +LL | u32::from(x_u16) > x_u32; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:38:17 + | +LL | x_u16 > x_u64; + | ^^^^^ expected `u16`, found `u64` + | +help: you can convert `x_u16` from `u16` to `u64`, matching the type of `x_u64` + | +LL | u64::from(x_u16) > x_u64; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:40:17 + | +LL | x_u16 > x_u128; + | ^^^^^^ expected `u16`, found `u128` + | +help: you can convert `x_u16` from `u16` to `u128`, matching the type of `x_u128` + | +LL | u128::from(x_u16) > x_u128; + | +++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:42:17 + | +LL | x_u16 > x_usize; + | ^^^^^^^ expected `u16`, found `usize` + | +help: you can convert `x_u16` from `u16` to `usize`, matching the type of `x_usize` + | +LL | usize::from(x_u16) > x_usize; + | ++++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:45:17 + | +LL | x_u32 > x_u8; + | ^^^^ expected `u32`, found `u8` + | +help: you can convert a `u8` to a `u32` + | +LL | x_u32 > x_u8.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:47:17 + | +LL | x_u32 > x_u16; + | ^^^^^ expected `u32`, found `u16` + | +help: you can convert a `u16` to a `u32` + | +LL | x_u32 > x_u16.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:49:17 + | +LL | x_u32 > x_u64; + | ^^^^^ expected `u32`, found `u64` + | +help: you can convert `x_u32` from `u32` to `u64`, matching the type of `x_u64` + | +LL | u64::from(x_u32) > x_u64; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:51:17 + | +LL | x_u32 > x_u128; + | ^^^^^^ expected `u32`, found `u128` + | +help: you can convert `x_u32` from `u32` to `u128`, matching the type of `x_u128` + | +LL | u128::from(x_u32) > x_u128; + | +++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:53:17 + | +LL | x_u32 > x_usize; + | ^^^^^^^ expected `u32`, found `usize` + | +help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit + | +LL | x_u32 > x_usize.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:56:17 + | +LL | x_u64 > x_u8; + | ^^^^ expected `u64`, found `u8` + | +help: you can convert a `u8` to a `u64` + | +LL | x_u64 > x_u8.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:58:17 + | +LL | x_u64 > x_u16; + | ^^^^^ expected `u64`, found `u16` + | +help: you can convert a `u16` to a `u64` + | +LL | x_u64 > x_u16.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:60:17 + | +LL | x_u64 > x_u32; + | ^^^^^ expected `u64`, found `u32` + | +help: you can convert a `u32` to a `u64` + | +LL | x_u64 > x_u32.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:62:17 + | +LL | x_u64 > x_u128; + | ^^^^^^ expected `u64`, found `u128` + | +help: you can convert `x_u64` from `u64` to `u128`, matching the type of `x_u128` + | +LL | u128::from(x_u64) > x_u128; + | +++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:64:17 + | +LL | x_u64 > x_usize; + | ^^^^^^^ expected `u64`, found `usize` + | +help: you can convert a `usize` to a `u64` and panic if the converted value doesn't fit + | +LL | x_u64 > x_usize.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:67:18 + | +LL | x_u128 > x_u8; + | ^^^^ expected `u128`, found `u8` + | +help: you can convert a `u8` to a `u128` + | +LL | x_u128 > x_u8.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:69:18 + | +LL | x_u128 > x_u16; + | ^^^^^ expected `u128`, found `u16` + | +help: you can convert a `u16` to a `u128` + | +LL | x_u128 > x_u16.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:71:18 + | +LL | x_u128 > x_u32; + | ^^^^^ expected `u128`, found `u32` + | +help: you can convert a `u32` to a `u128` + | +LL | x_u128 > x_u32.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:73:18 + | +LL | x_u128 > x_u64; + | ^^^^^ expected `u128`, found `u64` + | +help: you can convert a `u64` to a `u128` + | +LL | x_u128 > x_u64.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:75:18 + | +LL | x_u128 > x_usize; + | ^^^^^^^ expected `u128`, found `usize` + | +help: you can convert a `usize` to a `u128` and panic if the converted value doesn't fit + | +LL | x_u128 > x_usize.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:78:19 + | +LL | x_usize > x_u8; + | ^^^^ expected `usize`, found `u8` + | +help: you can convert a `u8` to a `usize` + | +LL | x_usize > x_u8.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:80:19 + | +LL | x_usize > x_u16; + | ^^^^^ expected `usize`, found `u16` + | +help: you can convert a `u16` to a `usize` + | +LL | x_usize > x_u16.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:82:19 + | +LL | x_usize > x_u32; + | ^^^^^ expected `usize`, found `u32` + | +help: you can convert a `u32` to a `usize` and panic if the converted value doesn't fit + | +LL | x_usize > x_u32.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:84:19 + | +LL | x_usize > x_u64; + | ^^^^^ expected `usize`, found `u64` + | +help: you can convert a `u64` to a `usize` and panic if the converted value doesn't fit + | +LL | x_usize > x_u64.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:86:19 + | +LL | x_usize > x_u128; + | ^^^^^^ expected `usize`, found `u128` + | +help: you can convert a `u128` to a `usize` and panic if the converted value doesn't fit + | +LL | x_usize > x_u128.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:92:16 + | +LL | x_i8 > x_i16; + | ^^^^^ expected `i8`, found `i16` + | +help: you can convert `x_i8` from `i8` to `i16`, matching the type of `x_i16` + | +LL | i16::from(x_i8) > x_i16; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:94:16 + | +LL | x_i8 > x_i32; + | ^^^^^ expected `i8`, found `i32` + | +help: you can convert `x_i8` from `i8` to `i32`, matching the type of `x_i32` + | +LL | i32::from(x_i8) > x_i32; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:96:16 + | +LL | x_i8 > x_i64; + | ^^^^^ expected `i8`, found `i64` + | +help: you can convert `x_i8` from `i8` to `i64`, matching the type of `x_i64` + | +LL | i64::from(x_i8) > x_i64; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:98:16 + | +LL | x_i8 > x_i128; + | ^^^^^^ expected `i8`, found `i128` + | +help: you can convert `x_i8` from `i8` to `i128`, matching the type of `x_i128` + | +LL | i128::from(x_i8) > x_i128; + | +++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:100:16 + | +LL | x_i8 > x_isize; + | ^^^^^^^ expected `i8`, found `isize` + | +help: you can convert `x_i8` from `i8` to `isize`, matching the type of `x_isize` + | +LL | isize::from(x_i8) > x_isize; + | ++++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:103:17 + | +LL | x_i16 > x_i8; + | ^^^^ expected `i16`, found `i8` + | +help: you can convert an `i8` to an `i16` + | +LL | x_i16 > x_i8.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:105:17 + | +LL | x_i16 > x_i32; + | ^^^^^ expected `i16`, found `i32` + | +help: you can convert `x_i16` from `i16` to `i32`, matching the type of `x_i32` + | +LL | i32::from(x_i16) > x_i32; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:107:17 + | +LL | x_i16 > x_i64; + | ^^^^^ expected `i16`, found `i64` + | +help: you can convert `x_i16` from `i16` to `i64`, matching the type of `x_i64` + | +LL | i64::from(x_i16) > x_i64; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:109:17 + | +LL | x_i16 > x_i128; + | ^^^^^^ expected `i16`, found `i128` + | +help: you can convert `x_i16` from `i16` to `i128`, matching the type of `x_i128` + | +LL | i128::from(x_i16) > x_i128; + | +++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:111:17 + | +LL | x_i16 > x_isize; + | ^^^^^^^ expected `i16`, found `isize` + | +help: you can convert `x_i16` from `i16` to `isize`, matching the type of `x_isize` + | +LL | isize::from(x_i16) > x_isize; + | ++++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:114:17 + | +LL | x_i32 > x_i8; + | ^^^^ expected `i32`, found `i8` + | +help: you can convert an `i8` to an `i32` + | +LL | x_i32 > x_i8.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:116:17 + | +LL | x_i32 > x_i16; + | ^^^^^ expected `i32`, found `i16` + | +help: you can convert an `i16` to an `i32` + | +LL | x_i32 > x_i16.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:118:17 + | +LL | x_i32 > x_i64; + | ^^^^^ expected `i32`, found `i64` + | +help: you can convert `x_i32` from `i32` to `i64`, matching the type of `x_i64` + | +LL | i64::from(x_i32) > x_i64; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:120:17 + | +LL | x_i32 > x_i128; + | ^^^^^^ expected `i32`, found `i128` + | +help: you can convert `x_i32` from `i32` to `i128`, matching the type of `x_i128` + | +LL | i128::from(x_i32) > x_i128; + | +++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:122:17 + | +LL | x_i32 > x_isize; + | ^^^^^^^ expected `i32`, found `isize` + | +help: you can convert an `isize` to an `i32` and panic if the converted value doesn't fit + | +LL | x_i32 > x_isize.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:125:17 + | +LL | x_i64 > x_i8; + | ^^^^ expected `i64`, found `i8` + | +help: you can convert an `i8` to an `i64` + | +LL | x_i64 > x_i8.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:127:17 + | +LL | x_i64 > x_i16; + | ^^^^^ expected `i64`, found `i16` + | +help: you can convert an `i16` to an `i64` + | +LL | x_i64 > x_i16.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:129:17 + | +LL | x_i64 > x_i32; + | ^^^^^ expected `i64`, found `i32` + | +help: you can convert an `i32` to an `i64` + | +LL | x_i64 > x_i32.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:131:17 + | +LL | x_i64 > x_i128; + | ^^^^^^ expected `i64`, found `i128` + | +help: you can convert `x_i64` from `i64` to `i128`, matching the type of `x_i128` + | +LL | i128::from(x_i64) > x_i128; + | +++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:133:17 + | +LL | x_i64 > x_isize; + | ^^^^^^^ expected `i64`, found `isize` + | +help: you can convert an `isize` to an `i64` and panic if the converted value doesn't fit + | +LL | x_i64 > x_isize.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:136:18 + | +LL | x_i128 > x_i8; + | ^^^^ expected `i128`, found `i8` + | +help: you can convert an `i8` to an `i128` + | +LL | x_i128 > x_i8.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:138:18 + | +LL | x_i128 > x_i16; + | ^^^^^ expected `i128`, found `i16` + | +help: you can convert an `i16` to an `i128` + | +LL | x_i128 > x_i16.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:140:18 + | +LL | x_i128 > x_i32; + | ^^^^^ expected `i128`, found `i32` + | +help: you can convert an `i32` to an `i128` + | +LL | x_i128 > x_i32.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:142:18 + | +LL | x_i128 > x_i64; + | ^^^^^ expected `i128`, found `i64` + | +help: you can convert an `i64` to an `i128` + | +LL | x_i128 > x_i64.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:144:18 + | +LL | x_i128 > x_isize; + | ^^^^^^^ expected `i128`, found `isize` + | +help: you can convert an `isize` to an `i128` and panic if the converted value doesn't fit + | +LL | x_i128 > x_isize.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:147:19 + | +LL | x_isize > x_i8; + | ^^^^ expected `isize`, found `i8` + | +help: you can convert an `i8` to an `isize` + | +LL | x_isize > x_i8.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:149:19 + | +LL | x_isize > x_i16; + | ^^^^^ expected `isize`, found `i16` + | +help: you can convert an `i16` to an `isize` + | +LL | x_isize > x_i16.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:151:19 + | +LL | x_isize > x_i32; + | ^^^^^ expected `isize`, found `i32` + | +help: you can convert an `i32` to an `isize` and panic if the converted value doesn't fit + | +LL | x_isize > x_i32.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:153:19 + | +LL | x_isize > x_i64; + | ^^^^^ expected `isize`, found `i64` + | +help: you can convert an `i64` to an `isize` and panic if the converted value doesn't fit + | +LL | x_isize > x_i64.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:155:19 + | +LL | x_isize > x_i128; + | ^^^^^^ expected `isize`, found `i128` + | +help: you can convert an `i128` to an `isize` and panic if the converted value doesn't fit + | +LL | x_isize > x_i128.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:161:16 + | +LL | x_u8 > x_i8; + | ^^^^ expected `u8`, found `i8` + | +help: you can convert an `i8` to a `u8` and panic if the converted value doesn't fit + | +LL | x_u8 > x_i8.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:163:16 + | +LL | x_u8 > x_i16; + | ^^^^^ expected `u8`, found `i16` + | +help: you can convert `x_u8` from `u8` to `i16`, matching the type of `x_i16` + | +LL | i16::from(x_u8) > x_i16; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:165:16 + | +LL | x_u8 > x_i32; + | ^^^^^ expected `u8`, found `i32` + | +help: you can convert `x_u8` from `u8` to `i32`, matching the type of `x_i32` + | +LL | i32::from(x_u8) > x_i32; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:167:16 + | +LL | x_u8 > x_i64; + | ^^^^^ expected `u8`, found `i64` + | +help: you can convert `x_u8` from `u8` to `i64`, matching the type of `x_i64` + | +LL | i64::from(x_u8) > x_i64; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:169:16 + | +LL | x_u8 > x_i128; + | ^^^^^^ expected `u8`, found `i128` + | +help: you can convert `x_u8` from `u8` to `i128`, matching the type of `x_i128` + | +LL | i128::from(x_u8) > x_i128; + | +++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:171:16 + | +LL | x_u8 > x_isize; + | ^^^^^^^ expected `u8`, found `isize` + | +help: you can convert `x_u8` from `u8` to `isize`, matching the type of `x_isize` + | +LL | isize::from(x_u8) > x_isize; + | ++++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:174:17 + | +LL | x_u16 > x_i8; + | ^^^^ expected `u16`, found `i8` + | +help: you can convert an `i8` to a `u16` and panic if the converted value doesn't fit + | +LL | x_u16 > x_i8.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:176:17 + | +LL | x_u16 > x_i16; + | ^^^^^ expected `u16`, found `i16` + | +help: you can convert an `i16` to a `u16` and panic if the converted value doesn't fit + | +LL | x_u16 > x_i16.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:178:17 + | +LL | x_u16 > x_i32; + | ^^^^^ expected `u16`, found `i32` + | +help: you can convert `x_u16` from `u16` to `i32`, matching the type of `x_i32` + | +LL | i32::from(x_u16) > x_i32; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:180:17 + | +LL | x_u16 > x_i64; + | ^^^^^ expected `u16`, found `i64` + | +help: you can convert `x_u16` from `u16` to `i64`, matching the type of `x_i64` + | +LL | i64::from(x_u16) > x_i64; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:182:17 + | +LL | x_u16 > x_i128; + | ^^^^^^ expected `u16`, found `i128` + | +help: you can convert `x_u16` from `u16` to `i128`, matching the type of `x_i128` + | +LL | i128::from(x_u16) > x_i128; + | +++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:184:17 + | +LL | x_u16 > x_isize; + | ^^^^^^^ expected `u16`, found `isize` + | +help: you can convert an `isize` to a `u16` and panic if the converted value doesn't fit + | +LL | x_u16 > x_isize.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:187:17 + | +LL | x_u32 > x_i8; + | ^^^^ expected `u32`, found `i8` + | +help: you can convert an `i8` to a `u32` and panic if the converted value doesn't fit + | +LL | x_u32 > x_i8.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:189:17 + | +LL | x_u32 > x_i16; + | ^^^^^ expected `u32`, found `i16` + | +help: you can convert an `i16` to a `u32` and panic if the converted value doesn't fit + | +LL | x_u32 > x_i16.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:191:17 + | +LL | x_u32 > x_i32; + | ^^^^^ expected `u32`, found `i32` + | +help: you can convert an `i32` to a `u32` and panic if the converted value doesn't fit + | +LL | x_u32 > x_i32.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:193:17 + | +LL | x_u32 > x_i64; + | ^^^^^ expected `u32`, found `i64` + | +help: you can convert `x_u32` from `u32` to `i64`, matching the type of `x_i64` + | +LL | i64::from(x_u32) > x_i64; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:195:17 + | +LL | x_u32 > x_i128; + | ^^^^^^ expected `u32`, found `i128` + | +help: you can convert `x_u32` from `u32` to `i128`, matching the type of `x_i128` + | +LL | i128::from(x_u32) > x_i128; + | +++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:197:17 + | +LL | x_u32 > x_isize; + | ^^^^^^^ expected `u32`, found `isize` + | +help: you can convert an `isize` to a `u32` and panic if the converted value doesn't fit + | +LL | x_u32 > x_isize.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:200:17 + | +LL | x_u64 > x_i8; + | ^^^^ expected `u64`, found `i8` + | +help: you can convert an `i8` to a `u64` and panic if the converted value doesn't fit + | +LL | x_u64 > x_i8.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:202:17 + | +LL | x_u64 > x_i16; + | ^^^^^ expected `u64`, found `i16` + | +help: you can convert an `i16` to a `u64` and panic if the converted value doesn't fit + | +LL | x_u64 > x_i16.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:204:17 + | +LL | x_u64 > x_i32; + | ^^^^^ expected `u64`, found `i32` + | +help: you can convert an `i32` to a `u64` and panic if the converted value doesn't fit + | +LL | x_u64 > x_i32.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:206:17 + | +LL | x_u64 > x_i64; + | ^^^^^ expected `u64`, found `i64` + | +help: you can convert an `i64` to a `u64` and panic if the converted value doesn't fit + | +LL | x_u64 > x_i64.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:208:17 + | +LL | x_u64 > x_i128; + | ^^^^^^ expected `u64`, found `i128` + | +help: you can convert `x_u64` from `u64` to `i128`, matching the type of `x_i128` + | +LL | i128::from(x_u64) > x_i128; + | +++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:210:17 + | +LL | x_u64 > x_isize; + | ^^^^^^^ expected `u64`, found `isize` + | +help: you can convert an `isize` to a `u64` and panic if the converted value doesn't fit + | +LL | x_u64 > x_isize.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:213:18 + | +LL | x_u128 > x_i8; + | ^^^^ expected `u128`, found `i8` + | +help: you can convert an `i8` to a `u128` and panic if the converted value doesn't fit + | +LL | x_u128 > x_i8.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:215:18 + | +LL | x_u128 > x_i16; + | ^^^^^ expected `u128`, found `i16` + | +help: you can convert an `i16` to a `u128` and panic if the converted value doesn't fit + | +LL | x_u128 > x_i16.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:217:18 + | +LL | x_u128 > x_i32; + | ^^^^^ expected `u128`, found `i32` + | +help: you can convert an `i32` to a `u128` and panic if the converted value doesn't fit + | +LL | x_u128 > x_i32.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:219:18 + | +LL | x_u128 > x_i64; + | ^^^^^ expected `u128`, found `i64` + | +help: you can convert an `i64` to a `u128` and panic if the converted value doesn't fit + | +LL | x_u128 > x_i64.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:221:18 + | +LL | x_u128 > x_i128; + | ^^^^^^ expected `u128`, found `i128` + | +help: you can convert an `i128` to a `u128` and panic if the converted value doesn't fit + | +LL | x_u128 > x_i128.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:223:18 + | +LL | x_u128 > x_isize; + | ^^^^^^^ expected `u128`, found `isize` + | +help: you can convert an `isize` to a `u128` and panic if the converted value doesn't fit + | +LL | x_u128 > x_isize.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:226:19 + | +LL | x_usize > x_i8; + | ^^^^ expected `usize`, found `i8` + | +help: you can convert an `i8` to a `usize` and panic if the converted value doesn't fit + | +LL | x_usize > x_i8.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:228:19 + | +LL | x_usize > x_i16; + | ^^^^^ expected `usize`, found `i16` + | +help: you can convert an `i16` to a `usize` and panic if the converted value doesn't fit + | +LL | x_usize > x_i16.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:230:19 + | +LL | x_usize > x_i32; + | ^^^^^ expected `usize`, found `i32` + | +help: you can convert an `i32` to a `usize` and panic if the converted value doesn't fit + | +LL | x_usize > x_i32.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:232:19 + | +LL | x_usize > x_i64; + | ^^^^^ expected `usize`, found `i64` + | +help: you can convert an `i64` to a `usize` and panic if the converted value doesn't fit + | +LL | x_usize > x_i64.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:234:19 + | +LL | x_usize > x_i128; + | ^^^^^^ expected `usize`, found `i128` + | +help: you can convert an `i128` to a `usize` and panic if the converted value doesn't fit + | +LL | x_usize > x_i128.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:236:19 + | +LL | x_usize > x_isize; + | ^^^^^^^ expected `usize`, found `isize` + | +help: you can convert an `isize` to a `usize` and panic if the converted value doesn't fit + | +LL | x_usize > x_isize.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:242:16 + | +LL | x_i8 > x_u8; + | ^^^^ expected `i8`, found `u8` + | +help: you can convert a `u8` to an `i8` and panic if the converted value doesn't fit + | +LL | x_i8 > x_u8.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:244:16 + | +LL | x_i8 > x_u16; + | ^^^^^ expected `i8`, found `u16` + | +help: you can convert a `u16` to an `i8` and panic if the converted value doesn't fit + | +LL | x_i8 > x_u16.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:246:16 + | +LL | x_i8 > x_u32; + | ^^^^^ expected `i8`, found `u32` + | +help: you can convert a `u32` to an `i8` and panic if the converted value doesn't fit + | +LL | x_i8 > x_u32.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:248:16 + | +LL | x_i8 > x_u64; + | ^^^^^ expected `i8`, found `u64` + | +help: you can convert a `u64` to an `i8` and panic if the converted value doesn't fit + | +LL | x_i8 > x_u64.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:250:16 + | +LL | x_i8 > x_u128; + | ^^^^^^ expected `i8`, found `u128` + | +help: you can convert a `u128` to an `i8` and panic if the converted value doesn't fit + | +LL | x_i8 > x_u128.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:252:16 + | +LL | x_i8 > x_usize; + | ^^^^^^^ expected `i8`, found `usize` + | +help: you can convert a `usize` to an `i8` and panic if the converted value doesn't fit + | +LL | x_i8 > x_usize.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:255:17 + | +LL | x_i16 > x_u8; + | ^^^^ expected `i16`, found `u8` + | +help: you can convert a `u8` to an `i16` + | +LL | x_i16 > x_u8.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:257:17 + | +LL | x_i16 > x_u16; + | ^^^^^ expected `i16`, found `u16` + | +help: you can convert a `u16` to an `i16` and panic if the converted value doesn't fit + | +LL | x_i16 > x_u16.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:259:17 + | +LL | x_i16 > x_u32; + | ^^^^^ expected `i16`, found `u32` + | +help: you can convert a `u32` to an `i16` and panic if the converted value doesn't fit + | +LL | x_i16 > x_u32.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:261:17 + | +LL | x_i16 > x_u64; + | ^^^^^ expected `i16`, found `u64` + | +help: you can convert a `u64` to an `i16` and panic if the converted value doesn't fit + | +LL | x_i16 > x_u64.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:263:17 + | +LL | x_i16 > x_u128; + | ^^^^^^ expected `i16`, found `u128` + | +help: you can convert a `u128` to an `i16` and panic if the converted value doesn't fit + | +LL | x_i16 > x_u128.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:265:17 + | +LL | x_i16 > x_usize; + | ^^^^^^^ expected `i16`, found `usize` + | +help: you can convert a `usize` to an `i16` and panic if the converted value doesn't fit + | +LL | x_i16 > x_usize.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:268:17 + | +LL | x_i32 > x_u8; + | ^^^^ expected `i32`, found `u8` + | +help: you can convert a `u8` to an `i32` + | +LL | x_i32 > x_u8.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:270:17 + | +LL | x_i32 > x_u16; + | ^^^^^ expected `i32`, found `u16` + | +help: you can convert a `u16` to an `i32` + | +LL | x_i32 > x_u16.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:272:17 + | +LL | x_i32 > x_u32; + | ^^^^^ expected `i32`, found `u32` + | +help: you can convert a `u32` to an `i32` and panic if the converted value doesn't fit + | +LL | x_i32 > x_u32.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:274:17 + | +LL | x_i32 > x_u64; + | ^^^^^ expected `i32`, found `u64` + | +help: you can convert a `u64` to an `i32` and panic if the converted value doesn't fit + | +LL | x_i32 > x_u64.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:276:17 + | +LL | x_i32 > x_u128; + | ^^^^^^ expected `i32`, found `u128` + | +help: you can convert a `u128` to an `i32` and panic if the converted value doesn't fit + | +LL | x_i32 > x_u128.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:278:17 + | +LL | x_i32 > x_usize; + | ^^^^^^^ expected `i32`, found `usize` + | +help: you can convert a `usize` to an `i32` and panic if the converted value doesn't fit + | +LL | x_i32 > x_usize.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:281:17 + | +LL | x_i64 > x_u8; + | ^^^^ expected `i64`, found `u8` + | +help: you can convert a `u8` to an `i64` + | +LL | x_i64 > x_u8.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:283:17 + | +LL | x_i64 > x_u16; + | ^^^^^ expected `i64`, found `u16` + | +help: you can convert a `u16` to an `i64` + | +LL | x_i64 > x_u16.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:285:17 + | +LL | x_i64 > x_u32; + | ^^^^^ expected `i64`, found `u32` + | +help: you can convert a `u32` to an `i64` + | +LL | x_i64 > x_u32.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:287:17 + | +LL | x_i64 > x_u64; + | ^^^^^ expected `i64`, found `u64` + | +help: you can convert a `u64` to an `i64` and panic if the converted value doesn't fit + | +LL | x_i64 > x_u64.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:289:17 + | +LL | x_i64 > x_u128; + | ^^^^^^ expected `i64`, found `u128` + | +help: you can convert a `u128` to an `i64` and panic if the converted value doesn't fit + | +LL | x_i64 > x_u128.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:291:17 + | +LL | x_i64 > x_usize; + | ^^^^^^^ expected `i64`, found `usize` + | +help: you can convert a `usize` to an `i64` and panic if the converted value doesn't fit + | +LL | x_i64 > x_usize.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:294:18 + | +LL | x_i128 > x_u8; + | ^^^^ expected `i128`, found `u8` + | +help: you can convert a `u8` to an `i128` + | +LL | x_i128 > x_u8.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:296:18 + | +LL | x_i128 > x_u16; + | ^^^^^ expected `i128`, found `u16` + | +help: you can convert a `u16` to an `i128` + | +LL | x_i128 > x_u16.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:298:18 + | +LL | x_i128 > x_u32; + | ^^^^^ expected `i128`, found `u32` + | +help: you can convert a `u32` to an `i128` + | +LL | x_i128 > x_u32.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:300:18 + | +LL | x_i128 > x_u64; + | ^^^^^ expected `i128`, found `u64` + | +help: you can convert a `u64` to an `i128` + | +LL | x_i128 > x_u64.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:302:18 + | +LL | x_i128 > x_u128; + | ^^^^^^ expected `i128`, found `u128` + | +help: you can convert a `u128` to an `i128` and panic if the converted value doesn't fit + | +LL | x_i128 > x_u128.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:304:18 + | +LL | x_i128 > x_usize; + | ^^^^^^^ expected `i128`, found `usize` + | +help: you can convert a `usize` to an `i128` and panic if the converted value doesn't fit + | +LL | x_i128 > x_usize.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:307:19 + | +LL | x_isize > x_u8; + | ^^^^ expected `isize`, found `u8` + | +help: you can convert a `u8` to an `isize` + | +LL | x_isize > x_u8.into(); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:309:19 + | +LL | x_isize > x_u16; + | ^^^^^ expected `isize`, found `u16` + | +help: you can convert a `u16` to an `isize` and panic if the converted value doesn't fit + | +LL | x_isize > x_u16.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:311:19 + | +LL | x_isize > x_u32; + | ^^^^^ expected `isize`, found `u32` + | +help: you can convert a `u32` to an `isize` and panic if the converted value doesn't fit + | +LL | x_isize > x_u32.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:313:19 + | +LL | x_isize > x_u64; + | ^^^^^ expected `isize`, found `u64` + | +help: you can convert a `u64` to an `isize` and panic if the converted value doesn't fit + | +LL | x_isize > x_u64.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:315:19 + | +LL | x_isize > x_u128; + | ^^^^^^ expected `isize`, found `u128` + | +help: you can convert a `u128` to an `isize` and panic if the converted value doesn't fit + | +LL | x_isize > x_u128.try_into().unwrap(); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast-binop.rs:317:19 + | +LL | x_isize > x_usize; + | ^^^^^^^ expected `isize`, found `usize` + | +help: you can convert a `usize` to an `isize` and panic if the converted value doesn't fit + | +LL | x_isize > x_usize.try_into().unwrap(); + | ++++++++++++++++++++ + +error: aborting due to 132 previous errors + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/numeric/numeric-cast-no-fix.rs b/src/test/ui/numeric/numeric-cast-no-fix.rs new file mode 100644 index 000000000..63e5f098a --- /dev/null +++ b/src/test/ui/numeric/numeric-cast-no-fix.rs @@ -0,0 +1,87 @@ +#[allow(unused_must_use)] +fn main() { + let x_usize: usize = 1; + let x_u128: u128 = 2; + let x_u64: u64 = 3; + let x_u32: u32 = 4; + let x_u16: u16 = 5; + let x_u8: u8 = 6; + + x_usize > -1_isize; + //~^ ERROR mismatched types + x_u128 > -1_isize; + //~^ ERROR mismatched types + x_u64 > -1_isize; + //~^ ERROR mismatched types + x_u32 > -1_isize; + //~^ ERROR mismatched types + x_u16 > -1_isize; + //~^ ERROR mismatched types + x_u8 > -1_isize; + //~^ ERROR mismatched types + + x_usize > -1_i128; + //~^ ERROR mismatched types + x_u128 > -1_i128; + //~^ ERROR mismatched types + x_u64 > -1_i128; + //~^ ERROR mismatched types + x_u32 > -1_i128; + //~^ ERROR mismatched types + x_u16 > -1_i128; + //~^ ERROR mismatched types + x_u8 > -1_i128; + //~^ ERROR mismatched types + + x_usize > -1_i64; + //~^ ERROR mismatched types + x_u128 > -1_i64; + //~^ ERROR mismatched types + x_u64 > -1_i64; + //~^ ERROR mismatched types + x_u32 > -1_i64; + //~^ ERROR mismatched types + x_u16 > -1_i64; + //~^ ERROR mismatched types + x_u8 > -1_i64; + //~^ ERROR mismatched types + + x_usize > -1_i32; + //~^ ERROR mismatched types + x_u128 > -1_i32; + //~^ ERROR mismatched types + x_u64 > -1_i32; + //~^ ERROR mismatched types + x_u32 > -1_i32; + //~^ ERROR mismatched types + x_u16 > -1_i32; + //~^ ERROR mismatched types + x_u8 > -1_i32; + //~^ ERROR mismatched types + + x_usize > -1_i16; + //~^ ERROR mismatched types + x_u128 > -1_i16; + //~^ ERROR mismatched types + x_u64 > -1_i16; + //~^ ERROR mismatched types + x_u32 > -1_i16; + //~^ ERROR mismatched types + x_u16 > -1_i16; + //~^ ERROR mismatched types + x_u8 > -1_i16; + //~^ ERROR mismatched types + + x_usize > -1_i8; + //~^ ERROR mismatched types + x_u128 > -1_i8; + //~^ ERROR mismatched types + x_u64 > -1_i8; + //~^ ERROR mismatched types + x_u32 > -1_i8; + //~^ ERROR mismatched types + x_u16 > -1_i8; + //~^ ERROR mismatched types + x_u8 > -1_i8; + //~^ ERROR mismatched types +} diff --git a/src/test/ui/numeric/numeric-cast-no-fix.stderr b/src/test/ui/numeric/numeric-cast-no-fix.stderr new file mode 100644 index 000000000..e4843206d --- /dev/null +++ b/src/test/ui/numeric/numeric-cast-no-fix.stderr @@ -0,0 +1,324 @@ +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:10:15 + | +LL | x_usize > -1_isize; + | ^^^^^^^^ expected `usize`, found `isize` + | + = note: `-1_isize` cannot fit into type `usize` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:12:14 + | +LL | x_u128 > -1_isize; + | ^^^^^^^^ expected `u128`, found `isize` + | + = note: `-1_isize` cannot fit into type `u128` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:14:13 + | +LL | x_u64 > -1_isize; + | ^^^^^^^^ expected `u64`, found `isize` + | + = note: `-1_isize` cannot fit into type `u64` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:16:13 + | +LL | x_u32 > -1_isize; + | ^^^^^^^^ expected `u32`, found `isize` + | + = note: `-1_isize` cannot fit into type `u32` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:18:13 + | +LL | x_u16 > -1_isize; + | ^^^^^^^^ expected `u16`, found `isize` + | + = note: `-1_isize` cannot fit into type `u16` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:20:12 + | +LL | x_u8 > -1_isize; + | ^^^^^^^^ expected `u8`, found `isize` + | +help: you can convert `x_u8` from `u8` to `isize`, matching the type of `-1_isize` + | +LL | isize::from(x_u8) > -1_isize; + | ++++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:23:15 + | +LL | x_usize > -1_i128; + | ^^^^^^^ expected `usize`, found `i128` + | + = note: `-1_i128` cannot fit into type `usize` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:25:14 + | +LL | x_u128 > -1_i128; + | ^^^^^^^ expected `u128`, found `i128` + | + = note: `-1_i128` cannot fit into type `u128` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:27:13 + | +LL | x_u64 > -1_i128; + | ^^^^^^^ expected `u64`, found `i128` + | +help: you can convert `x_u64` from `u64` to `i128`, matching the type of `-1_i128` + | +LL | i128::from(x_u64) > -1_i128; + | +++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:29:13 + | +LL | x_u32 > -1_i128; + | ^^^^^^^ expected `u32`, found `i128` + | +help: you can convert `x_u32` from `u32` to `i128`, matching the type of `-1_i128` + | +LL | i128::from(x_u32) > -1_i128; + | +++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:31:13 + | +LL | x_u16 > -1_i128; + | ^^^^^^^ expected `u16`, found `i128` + | +help: you can convert `x_u16` from `u16` to `i128`, matching the type of `-1_i128` + | +LL | i128::from(x_u16) > -1_i128; + | +++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:33:12 + | +LL | x_u8 > -1_i128; + | ^^^^^^^ expected `u8`, found `i128` + | +help: you can convert `x_u8` from `u8` to `i128`, matching the type of `-1_i128` + | +LL | i128::from(x_u8) > -1_i128; + | +++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:36:15 + | +LL | x_usize > -1_i64; + | ^^^^^^ expected `usize`, found `i64` + | + = note: `-1_i64` cannot fit into type `usize` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:38:14 + | +LL | x_u128 > -1_i64; + | ^^^^^^ expected `u128`, found `i64` + | + = note: `-1_i64` cannot fit into type `u128` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:40:13 + | +LL | x_u64 > -1_i64; + | ^^^^^^ expected `u64`, found `i64` + | + = note: `-1_i64` cannot fit into type `u64` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:42:13 + | +LL | x_u32 > -1_i64; + | ^^^^^^ expected `u32`, found `i64` + | +help: you can convert `x_u32` from `u32` to `i64`, matching the type of `-1_i64` + | +LL | i64::from(x_u32) > -1_i64; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:44:13 + | +LL | x_u16 > -1_i64; + | ^^^^^^ expected `u16`, found `i64` + | +help: you can convert `x_u16` from `u16` to `i64`, matching the type of `-1_i64` + | +LL | i64::from(x_u16) > -1_i64; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:46:12 + | +LL | x_u8 > -1_i64; + | ^^^^^^ expected `u8`, found `i64` + | +help: you can convert `x_u8` from `u8` to `i64`, matching the type of `-1_i64` + | +LL | i64::from(x_u8) > -1_i64; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:49:15 + | +LL | x_usize > -1_i32; + | ^^^^^^ expected `usize`, found `i32` + | + = note: `-1_i32` cannot fit into type `usize` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:51:14 + | +LL | x_u128 > -1_i32; + | ^^^^^^ expected `u128`, found `i32` + | + = note: `-1_i32` cannot fit into type `u128` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:53:13 + | +LL | x_u64 > -1_i32; + | ^^^^^^ expected `u64`, found `i32` + | + = note: `-1_i32` cannot fit into type `u64` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:55:13 + | +LL | x_u32 > -1_i32; + | ^^^^^^ expected `u32`, found `i32` + | + = note: `-1_i32` cannot fit into type `u32` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:57:13 + | +LL | x_u16 > -1_i32; + | ^^^^^^ expected `u16`, found `i32` + | +help: you can convert `x_u16` from `u16` to `i32`, matching the type of `-1_i32` + | +LL | i32::from(x_u16) > -1_i32; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:59:12 + | +LL | x_u8 > -1_i32; + | ^^^^^^ expected `u8`, found `i32` + | +help: you can convert `x_u8` from `u8` to `i32`, matching the type of `-1_i32` + | +LL | i32::from(x_u8) > -1_i32; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:62:15 + | +LL | x_usize > -1_i16; + | ^^^^^^ expected `usize`, found `i16` + | + = note: `-1_i16` cannot fit into type `usize` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:64:14 + | +LL | x_u128 > -1_i16; + | ^^^^^^ expected `u128`, found `i16` + | + = note: `-1_i16` cannot fit into type `u128` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:66:13 + | +LL | x_u64 > -1_i16; + | ^^^^^^ expected `u64`, found `i16` + | + = note: `-1_i16` cannot fit into type `u64` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:68:13 + | +LL | x_u32 > -1_i16; + | ^^^^^^ expected `u32`, found `i16` + | + = note: `-1_i16` cannot fit into type `u32` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:70:13 + | +LL | x_u16 > -1_i16; + | ^^^^^^ expected `u16`, found `i16` + | + = note: `-1_i16` cannot fit into type `u16` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:72:12 + | +LL | x_u8 > -1_i16; + | ^^^^^^ expected `u8`, found `i16` + | +help: you can convert `x_u8` from `u8` to `i16`, matching the type of `-1_i16` + | +LL | i16::from(x_u8) > -1_i16; + | ++++++++++ + + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:75:15 + | +LL | x_usize > -1_i8; + | ^^^^^ expected `usize`, found `i8` + | + = note: `-1_i8` cannot fit into type `usize` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:77:14 + | +LL | x_u128 > -1_i8; + | ^^^^^ expected `u128`, found `i8` + | + = note: `-1_i8` cannot fit into type `u128` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:79:13 + | +LL | x_u64 > -1_i8; + | ^^^^^ expected `u64`, found `i8` + | + = note: `-1_i8` cannot fit into type `u64` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:81:13 + | +LL | x_u32 > -1_i8; + | ^^^^^ expected `u32`, found `i8` + | + = note: `-1_i8` cannot fit into type `u32` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:83:13 + | +LL | x_u16 > -1_i8; + | ^^^^^ expected `u16`, found `i8` + | + = note: `-1_i8` cannot fit into type `u16` + +error[E0308]: mismatched types + --> $DIR/numeric-cast-no-fix.rs:85:12 + | +LL | x_u8 > -1_i8; + | ^^^^^ expected `u8`, found `i8` + | + = note: `-1_i8` cannot fit into type `u8` + +error: aborting due to 36 previous errors + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/numeric/numeric-cast-without-suggestion.rs b/src/test/ui/numeric/numeric-cast-without-suggestion.rs new file mode 100644 index 000000000..faf24a8c1 --- /dev/null +++ b/src/test/ui/numeric/numeric-cast-without-suggestion.rs @@ -0,0 +1,38 @@ +fn foo<N>(_x: N) {} + +fn main() { + let x_usize: usize = 1; + let x_u64: u64 = 2; + let x_u32: u32 = 3; + let x_u16: u16 = 4; + let x_u8: u8 = 5; + let x_isize: isize = 6; + let x_i64: i64 = 7; + let x_i32: i32 = 8; + let x_i16: i16 = 9; + let x_i8: i8 = 10; + let x_f64: f64 = 11.0; + let x_f32: f32 = 12.0; + + foo::<usize>(x_f64); //~ ERROR mismatched types + foo::<usize>(x_f32); //~ ERROR mismatched types + foo::<isize>(x_f64); //~ ERROR mismatched types + foo::<isize>(x_f32); //~ ERROR mismatched types + foo::<u64>(x_f64); //~ ERROR mismatched types + foo::<u64>(x_f32); //~ ERROR mismatched types + foo::<i64>(x_f64); //~ ERROR mismatched types + foo::<i64>(x_f32); //~ ERROR mismatched types + foo::<u32>(x_f64); //~ ERROR mismatched types + foo::<u32>(x_f32); //~ ERROR mismatched types + foo::<i32>(x_f64); //~ ERROR mismatched types + foo::<i32>(x_f32); //~ ERROR mismatched types + foo::<u16>(x_f64); //~ ERROR mismatched types + foo::<u16>(x_f32); //~ ERROR mismatched types + foo::<i16>(x_f64); //~ ERROR mismatched types + foo::<i16>(x_f32); //~ ERROR mismatched types + foo::<u8>(x_f64); //~ ERROR mismatched types + foo::<u8>(x_f32); //~ ERROR mismatched types + foo::<i8>(x_f64); //~ ERROR mismatched types + foo::<i8>(x_f32); //~ ERROR mismatched types + foo::<f32>(x_f64); //~ ERROR mismatched types +} diff --git a/src/test/ui/numeric/numeric-cast-without-suggestion.stderr b/src/test/ui/numeric/numeric-cast-without-suggestion.stderr new file mode 100644 index 000000000..581b548ab --- /dev/null +++ b/src/test/ui/numeric/numeric-cast-without-suggestion.stderr @@ -0,0 +1,297 @@ +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:17:18 + | +LL | foo::<usize>(x_f64); + | ------------ ^^^^^ expected `usize`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:18:18 + | +LL | foo::<usize>(x_f32); + | ------------ ^^^^^ expected `usize`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:19:18 + | +LL | foo::<isize>(x_f64); + | ------------ ^^^^^ expected `isize`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:20:18 + | +LL | foo::<isize>(x_f32); + | ------------ ^^^^^ expected `isize`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:21:16 + | +LL | foo::<u64>(x_f64); + | ---------- ^^^^^ expected `u64`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:22:16 + | +LL | foo::<u64>(x_f32); + | ---------- ^^^^^ expected `u64`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:23:16 + | +LL | foo::<i64>(x_f64); + | ---------- ^^^^^ expected `i64`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:24:16 + | +LL | foo::<i64>(x_f32); + | ---------- ^^^^^ expected `i64`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:25:16 + | +LL | foo::<u32>(x_f64); + | ---------- ^^^^^ expected `u32`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:26:16 + | +LL | foo::<u32>(x_f32); + | ---------- ^^^^^ expected `u32`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:27:16 + | +LL | foo::<i32>(x_f64); + | ---------- ^^^^^ expected `i32`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:28:16 + | +LL | foo::<i32>(x_f32); + | ---------- ^^^^^ expected `i32`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:29:16 + | +LL | foo::<u16>(x_f64); + | ---------- ^^^^^ expected `u16`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:30:16 + | +LL | foo::<u16>(x_f32); + | ---------- ^^^^^ expected `u16`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:31:16 + | +LL | foo::<i16>(x_f64); + | ---------- ^^^^^ expected `i16`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:32:16 + | +LL | foo::<i16>(x_f32); + | ---------- ^^^^^ expected `i16`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:33:15 + | +LL | foo::<u8>(x_f64); + | --------- ^^^^^ expected `u8`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:34:15 + | +LL | foo::<u8>(x_f32); + | --------- ^^^^^ expected `u8`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:35:15 + | +LL | foo::<i8>(x_f64); + | --------- ^^^^^ expected `i8`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:36:15 + | +LL | foo::<i8>(x_f32); + | --------- ^^^^^ expected `i8`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error[E0308]: mismatched types + --> $DIR/numeric-cast-without-suggestion.rs:37:16 + | +LL | foo::<f32>(x_f64); + | ---------- ^^^^^ expected `f32`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast-without-suggestion.rs:1:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- + +error: aborting due to 21 previous errors + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/numeric/numeric-cast.fixed b/src/test/ui/numeric/numeric-cast.fixed new file mode 100644 index 000000000..cf0560a10 --- /dev/null +++ b/src/test/ui/numeric/numeric-cast.fixed @@ -0,0 +1,293 @@ +// run-rustfix + +// The `try_into` suggestion doesn't include this, but we do suggest it after applying it +use std::convert::TryInto; + +fn foo<N>(_x: N) {} + +fn main() { + let x_usize: usize = 1; + let x_u64: u64 = 2; + let x_u32: u32 = 3; + let x_u16: u16 = 4; + let x_u8: u8 = 5; + let x_isize: isize = 6; + let x_i64: i64 = 7; + let x_i32: i32 = 8; + let x_i16: i16 = 9; + let x_i8: i8 = 10; + let x_f64: f64 = 11.0; + let x_f32: f32 = 12.0; + + foo::<usize>(x_usize); + foo::<usize>(x_u64.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<usize>(x_u32.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<usize>(x_u16.into()); + //~^ ERROR mismatched types + foo::<usize>(x_u8.into()); + //~^ ERROR mismatched types + foo::<usize>(x_isize.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<usize>(x_i64.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<usize>(x_i32.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<usize>(x_i16.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<usize>(x_i8.try_into().unwrap()); + //~^ ERROR mismatched types + // foo::<usize>(x_f64); + // foo::<usize>(x_f32); + + foo::<isize>(x_usize.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<isize>(x_u64.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<isize>(x_u32.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<isize>(x_u16.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<isize>(x_u8.into()); + //~^ ERROR mismatched types + foo::<isize>(x_isize); + foo::<isize>(x_i64.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<isize>(x_i32.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<isize>(x_i16.into()); + //~^ ERROR mismatched types + foo::<isize>(x_i8.into()); + //~^ ERROR mismatched types + // foo::<isize>(x_f64); + // foo::<isize>(x_f32); + + foo::<u64>(x_usize.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u64>(x_u64); + foo::<u64>(x_u32.into()); + //~^ ERROR mismatched types + foo::<u64>(x_u16.into()); + //~^ ERROR mismatched types + foo::<u64>(x_u8.into()); + //~^ ERROR mismatched types + foo::<u64>(x_isize.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u64>(x_i64.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u64>(x_i32.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u64>(x_i16.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u64>(x_i8.try_into().unwrap()); + //~^ ERROR mismatched types + // foo::<u64>(x_f64); + // foo::<u64>(x_f32); + + foo::<i64>(x_usize.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i64>(x_u64.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i64>(x_u32.into()); + //~^ ERROR mismatched types + foo::<i64>(x_u16.into()); + //~^ ERROR mismatched types + foo::<i64>(x_u8.into()); + //~^ ERROR mismatched types + foo::<i64>(x_isize.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i64>(x_i64); + foo::<i64>(x_i32.into()); + //~^ ERROR mismatched types + foo::<i64>(x_i16.into()); + //~^ ERROR mismatched types + foo::<i64>(x_i8.into()); + //~^ ERROR mismatched types + // foo::<i64>(x_f64); + // foo::<i64>(x_f32); + + foo::<u32>(x_usize.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u32>(x_u64.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u32>(x_u32); + foo::<u32>(x_u16.into()); + //~^ ERROR mismatched types + foo::<u32>(x_u8.into()); + //~^ ERROR mismatched types + foo::<u32>(x_isize.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u32>(x_i64.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u32>(x_i32.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u32>(x_i16.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u32>(x_i8.try_into().unwrap()); + //~^ ERROR mismatched types + // foo::<u32>(x_f64); + // foo::<u32>(x_f32); + + foo::<i32>(x_usize.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i32>(x_u64.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i32>(x_u32.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i32>(x_u16.into()); + //~^ ERROR mismatched types + foo::<i32>(x_u8.into()); + //~^ ERROR mismatched types + foo::<i32>(x_isize.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i32>(x_i64.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i32>(x_i32); + foo::<i32>(x_i16.into()); + //~^ ERROR mismatched types + foo::<i32>(x_i8.into()); + //~^ ERROR mismatched types + // foo::<i32>(x_f64); + // foo::<i32>(x_f32); + + foo::<u16>(x_usize.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u16>(x_u64.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u16>(x_u32.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u16>(x_u16); + foo::<u16>(x_u8.into()); + //~^ ERROR mismatched types + foo::<u16>(x_isize.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u16>(x_i64.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u16>(x_i32.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u16>(x_i16.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u16>(x_i8.try_into().unwrap()); + //~^ ERROR mismatched types + // foo::<u16>(x_f64); + // foo::<u16>(x_f32); + + foo::<i16>(x_usize.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i16>(x_u64.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i16>(x_u32.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i16>(x_u16.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i16>(x_u8.into()); + //~^ ERROR mismatched types + foo::<i16>(x_isize.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i16>(x_i64.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i16>(x_i32.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i16>(x_i16); + foo::<i16>(x_i8.into()); + //~^ ERROR mismatched types + // foo::<i16>(x_f64); + // foo::<i16>(x_f32); + + foo::<u8>(x_usize.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u8>(x_u64.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u8>(x_u32.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u8>(x_u16.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u8>(x_u8); + foo::<u8>(x_isize.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u8>(x_i64.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u8>(x_i32.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u8>(x_i16.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<u8>(x_i8.try_into().unwrap()); + //~^ ERROR mismatched types + // foo::<u8>(x_f64); + // foo::<u8>(x_f32); + + foo::<i8>(x_usize.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i8>(x_u64.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i8>(x_u32.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i8>(x_u16.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i8>(x_u8.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i8>(x_isize.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i8>(x_i64.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i8>(x_i32.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i8>(x_i16.try_into().unwrap()); + //~^ ERROR mismatched types + foo::<i8>(x_i8); + // foo::<i8>(x_f64); + // foo::<i8>(x_f32); + + foo::<f64>(x_usize as f64); + //~^ ERROR mismatched types + foo::<f64>(x_u64 as f64); + //~^ ERROR mismatched types + foo::<f64>(x_u32.into()); + //~^ ERROR mismatched types + foo::<f64>(x_u16.into()); + //~^ ERROR mismatched types + foo::<f64>(x_u8.into()); + //~^ ERROR mismatched types + foo::<f64>(x_isize as f64); + //~^ ERROR mismatched types + foo::<f64>(x_i64 as f64); + //~^ ERROR mismatched types + foo::<f64>(x_i32.into()); + //~^ ERROR mismatched types + foo::<f64>(x_i16.into()); + //~^ ERROR mismatched types + foo::<f64>(x_i8.into()); + //~^ ERROR mismatched types + foo::<f64>(x_f64); + foo::<f64>(x_f32.into()); + //~^ ERROR mismatched types + + foo::<f32>(x_usize as f32); + //~^ ERROR mismatched types + foo::<f32>(x_u64 as f32); + //~^ ERROR mismatched types + foo::<f32>(x_u32 as f32); + //~^ ERROR mismatched types + foo::<f32>(x_u16.into()); + //~^ ERROR mismatched types + foo::<f32>(x_u8.into()); + //~^ ERROR mismatched types + foo::<f32>(x_isize as f32); + //~^ ERROR mismatched types + foo::<f32>(x_i64 as f32); + //~^ ERROR mismatched types + foo::<f32>(x_i32 as f32); + //~^ ERROR mismatched types + foo::<f32>(x_i16.into()); + //~^ ERROR mismatched types + foo::<f32>(x_i8.into()); + //~^ ERROR mismatched types + // foo::<f32>(x_f64); + foo::<f32>(x_f32); + + foo::<u32>((x_u8 as u16).into()); + //~^ ERROR mismatched types + foo::<i32>((-x_i8).into()); + //~^ ERROR mismatched types +} diff --git a/src/test/ui/numeric/numeric-cast.rs b/src/test/ui/numeric/numeric-cast.rs new file mode 100644 index 000000000..7bddfc509 --- /dev/null +++ b/src/test/ui/numeric/numeric-cast.rs @@ -0,0 +1,293 @@ +// run-rustfix + +// The `try_into` suggestion doesn't include this, but we do suggest it after applying it +use std::convert::TryInto; + +fn foo<N>(_x: N) {} + +fn main() { + let x_usize: usize = 1; + let x_u64: u64 = 2; + let x_u32: u32 = 3; + let x_u16: u16 = 4; + let x_u8: u8 = 5; + let x_isize: isize = 6; + let x_i64: i64 = 7; + let x_i32: i32 = 8; + let x_i16: i16 = 9; + let x_i8: i8 = 10; + let x_f64: f64 = 11.0; + let x_f32: f32 = 12.0; + + foo::<usize>(x_usize); + foo::<usize>(x_u64); + //~^ ERROR mismatched types + foo::<usize>(x_u32); + //~^ ERROR mismatched types + foo::<usize>(x_u16); + //~^ ERROR mismatched types + foo::<usize>(x_u8); + //~^ ERROR mismatched types + foo::<usize>(x_isize); + //~^ ERROR mismatched types + foo::<usize>(x_i64); + //~^ ERROR mismatched types + foo::<usize>(x_i32); + //~^ ERROR mismatched types + foo::<usize>(x_i16); + //~^ ERROR mismatched types + foo::<usize>(x_i8); + //~^ ERROR mismatched types + // foo::<usize>(x_f64); + // foo::<usize>(x_f32); + + foo::<isize>(x_usize); + //~^ ERROR mismatched types + foo::<isize>(x_u64); + //~^ ERROR mismatched types + foo::<isize>(x_u32); + //~^ ERROR mismatched types + foo::<isize>(x_u16); + //~^ ERROR mismatched types + foo::<isize>(x_u8); + //~^ ERROR mismatched types + foo::<isize>(x_isize); + foo::<isize>(x_i64); + //~^ ERROR mismatched types + foo::<isize>(x_i32); + //~^ ERROR mismatched types + foo::<isize>(x_i16); + //~^ ERROR mismatched types + foo::<isize>(x_i8); + //~^ ERROR mismatched types + // foo::<isize>(x_f64); + // foo::<isize>(x_f32); + + foo::<u64>(x_usize); + //~^ ERROR mismatched types + foo::<u64>(x_u64); + foo::<u64>(x_u32); + //~^ ERROR mismatched types + foo::<u64>(x_u16); + //~^ ERROR mismatched types + foo::<u64>(x_u8); + //~^ ERROR mismatched types + foo::<u64>(x_isize); + //~^ ERROR mismatched types + foo::<u64>(x_i64); + //~^ ERROR mismatched types + foo::<u64>(x_i32); + //~^ ERROR mismatched types + foo::<u64>(x_i16); + //~^ ERROR mismatched types + foo::<u64>(x_i8); + //~^ ERROR mismatched types + // foo::<u64>(x_f64); + // foo::<u64>(x_f32); + + foo::<i64>(x_usize); + //~^ ERROR mismatched types + foo::<i64>(x_u64); + //~^ ERROR mismatched types + foo::<i64>(x_u32); + //~^ ERROR mismatched types + foo::<i64>(x_u16); + //~^ ERROR mismatched types + foo::<i64>(x_u8); + //~^ ERROR mismatched types + foo::<i64>(x_isize); + //~^ ERROR mismatched types + foo::<i64>(x_i64); + foo::<i64>(x_i32); + //~^ ERROR mismatched types + foo::<i64>(x_i16); + //~^ ERROR mismatched types + foo::<i64>(x_i8); + //~^ ERROR mismatched types + // foo::<i64>(x_f64); + // foo::<i64>(x_f32); + + foo::<u32>(x_usize); + //~^ ERROR mismatched types + foo::<u32>(x_u64); + //~^ ERROR mismatched types + foo::<u32>(x_u32); + foo::<u32>(x_u16); + //~^ ERROR mismatched types + foo::<u32>(x_u8); + //~^ ERROR mismatched types + foo::<u32>(x_isize); + //~^ ERROR mismatched types + foo::<u32>(x_i64); + //~^ ERROR mismatched types + foo::<u32>(x_i32); + //~^ ERROR mismatched types + foo::<u32>(x_i16); + //~^ ERROR mismatched types + foo::<u32>(x_i8); + //~^ ERROR mismatched types + // foo::<u32>(x_f64); + // foo::<u32>(x_f32); + + foo::<i32>(x_usize); + //~^ ERROR mismatched types + foo::<i32>(x_u64); + //~^ ERROR mismatched types + foo::<i32>(x_u32); + //~^ ERROR mismatched types + foo::<i32>(x_u16); + //~^ ERROR mismatched types + foo::<i32>(x_u8); + //~^ ERROR mismatched types + foo::<i32>(x_isize); + //~^ ERROR mismatched types + foo::<i32>(x_i64); + //~^ ERROR mismatched types + foo::<i32>(x_i32); + foo::<i32>(x_i16); + //~^ ERROR mismatched types + foo::<i32>(x_i8); + //~^ ERROR mismatched types + // foo::<i32>(x_f64); + // foo::<i32>(x_f32); + + foo::<u16>(x_usize); + //~^ ERROR mismatched types + foo::<u16>(x_u64); + //~^ ERROR mismatched types + foo::<u16>(x_u32); + //~^ ERROR mismatched types + foo::<u16>(x_u16); + foo::<u16>(x_u8); + //~^ ERROR mismatched types + foo::<u16>(x_isize); + //~^ ERROR mismatched types + foo::<u16>(x_i64); + //~^ ERROR mismatched types + foo::<u16>(x_i32); + //~^ ERROR mismatched types + foo::<u16>(x_i16); + //~^ ERROR mismatched types + foo::<u16>(x_i8); + //~^ ERROR mismatched types + // foo::<u16>(x_f64); + // foo::<u16>(x_f32); + + foo::<i16>(x_usize); + //~^ ERROR mismatched types + foo::<i16>(x_u64); + //~^ ERROR mismatched types + foo::<i16>(x_u32); + //~^ ERROR mismatched types + foo::<i16>(x_u16); + //~^ ERROR mismatched types + foo::<i16>(x_u8); + //~^ ERROR mismatched types + foo::<i16>(x_isize); + //~^ ERROR mismatched types + foo::<i16>(x_i64); + //~^ ERROR mismatched types + foo::<i16>(x_i32); + //~^ ERROR mismatched types + foo::<i16>(x_i16); + foo::<i16>(x_i8); + //~^ ERROR mismatched types + // foo::<i16>(x_f64); + // foo::<i16>(x_f32); + + foo::<u8>(x_usize); + //~^ ERROR mismatched types + foo::<u8>(x_u64); + //~^ ERROR mismatched types + foo::<u8>(x_u32); + //~^ ERROR mismatched types + foo::<u8>(x_u16); + //~^ ERROR mismatched types + foo::<u8>(x_u8); + foo::<u8>(x_isize); + //~^ ERROR mismatched types + foo::<u8>(x_i64); + //~^ ERROR mismatched types + foo::<u8>(x_i32); + //~^ ERROR mismatched types + foo::<u8>(x_i16); + //~^ ERROR mismatched types + foo::<u8>(x_i8); + //~^ ERROR mismatched types + // foo::<u8>(x_f64); + // foo::<u8>(x_f32); + + foo::<i8>(x_usize); + //~^ ERROR mismatched types + foo::<i8>(x_u64); + //~^ ERROR mismatched types + foo::<i8>(x_u32); + //~^ ERROR mismatched types + foo::<i8>(x_u16); + //~^ ERROR mismatched types + foo::<i8>(x_u8); + //~^ ERROR mismatched types + foo::<i8>(x_isize); + //~^ ERROR mismatched types + foo::<i8>(x_i64); + //~^ ERROR mismatched types + foo::<i8>(x_i32); + //~^ ERROR mismatched types + foo::<i8>(x_i16); + //~^ ERROR mismatched types + foo::<i8>(x_i8); + // foo::<i8>(x_f64); + // foo::<i8>(x_f32); + + foo::<f64>(x_usize); + //~^ ERROR mismatched types + foo::<f64>(x_u64); + //~^ ERROR mismatched types + foo::<f64>(x_u32); + //~^ ERROR mismatched types + foo::<f64>(x_u16); + //~^ ERROR mismatched types + foo::<f64>(x_u8); + //~^ ERROR mismatched types + foo::<f64>(x_isize); + //~^ ERROR mismatched types + foo::<f64>(x_i64); + //~^ ERROR mismatched types + foo::<f64>(x_i32); + //~^ ERROR mismatched types + foo::<f64>(x_i16); + //~^ ERROR mismatched types + foo::<f64>(x_i8); + //~^ ERROR mismatched types + foo::<f64>(x_f64); + foo::<f64>(x_f32); + //~^ ERROR mismatched types + + foo::<f32>(x_usize); + //~^ ERROR mismatched types + foo::<f32>(x_u64); + //~^ ERROR mismatched types + foo::<f32>(x_u32); + //~^ ERROR mismatched types + foo::<f32>(x_u16); + //~^ ERROR mismatched types + foo::<f32>(x_u8); + //~^ ERROR mismatched types + foo::<f32>(x_isize); + //~^ ERROR mismatched types + foo::<f32>(x_i64); + //~^ ERROR mismatched types + foo::<f32>(x_i32); + //~^ ERROR mismatched types + foo::<f32>(x_i16); + //~^ ERROR mismatched types + foo::<f32>(x_i8); + //~^ ERROR mismatched types + // foo::<f32>(x_f64); + foo::<f32>(x_f32); + + foo::<u32>(x_u8 as u16); + //~^ ERROR mismatched types + foo::<i32>(-x_i8); + //~^ ERROR mismatched types +} diff --git a/src/test/ui/numeric/numeric-cast.stderr b/src/test/ui/numeric/numeric-cast.stderr new file mode 100644 index 000000000..d347875d5 --- /dev/null +++ b/src/test/ui/numeric/numeric-cast.stderr @@ -0,0 +1,2037 @@ +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:23:18 + | +LL | foo::<usize>(x_u64); + | ------------ ^^^^^ expected `usize`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u64` to a `usize` and panic if the converted value doesn't fit + | +LL | foo::<usize>(x_u64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:25:18 + | +LL | foo::<usize>(x_u32); + | ------------ ^^^^^ expected `usize`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to a `usize` and panic if the converted value doesn't fit + | +LL | foo::<usize>(x_u32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:27:18 + | +LL | foo::<usize>(x_u16); + | ------------ ^^^^^ expected `usize`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to a `usize` + | +LL | foo::<usize>(x_u16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:29:18 + | +LL | foo::<usize>(x_u8); + | ------------ ^^^^ expected `usize`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to a `usize` + | +LL | foo::<usize>(x_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:31:18 + | +LL | foo::<usize>(x_isize); + | ------------ ^^^^^^^ expected `usize`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to a `usize` and panic if the converted value doesn't fit + | +LL | foo::<usize>(x_isize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:33:18 + | +LL | foo::<usize>(x_i64); + | ------------ ^^^^^ expected `usize`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to a `usize` and panic if the converted value doesn't fit + | +LL | foo::<usize>(x_i64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:35:18 + | +LL | foo::<usize>(x_i32); + | ------------ ^^^^^ expected `usize`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to a `usize` and panic if the converted value doesn't fit + | +LL | foo::<usize>(x_i32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:37:18 + | +LL | foo::<usize>(x_i16); + | ------------ ^^^^^ expected `usize`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to a `usize` and panic if the converted value doesn't fit + | +LL | foo::<usize>(x_i16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:39:18 + | +LL | foo::<usize>(x_i8); + | ------------ ^^^^ expected `usize`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to a `usize` and panic if the converted value doesn't fit + | +LL | foo::<usize>(x_i8.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:44:18 + | +LL | foo::<isize>(x_usize); + | ------------ ^^^^^^^ expected `isize`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `usize` to an `isize` and panic if the converted value doesn't fit + | +LL | foo::<isize>(x_usize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:46:18 + | +LL | foo::<isize>(x_u64); + | ------------ ^^^^^ expected `isize`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u64` to an `isize` and panic if the converted value doesn't fit + | +LL | foo::<isize>(x_u64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:48:18 + | +LL | foo::<isize>(x_u32); + | ------------ ^^^^^ expected `isize`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to an `isize` and panic if the converted value doesn't fit + | +LL | foo::<isize>(x_u32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:50:18 + | +LL | foo::<isize>(x_u16); + | ------------ ^^^^^ expected `isize`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to an `isize` and panic if the converted value doesn't fit + | +LL | foo::<isize>(x_u16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:52:18 + | +LL | foo::<isize>(x_u8); + | ------------ ^^^^ expected `isize`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to an `isize` + | +LL | foo::<isize>(x_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:55:18 + | +LL | foo::<isize>(x_i64); + | ------------ ^^^^^ expected `isize`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to an `isize` and panic if the converted value doesn't fit + | +LL | foo::<isize>(x_i64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:57:18 + | +LL | foo::<isize>(x_i32); + | ------------ ^^^^^ expected `isize`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to an `isize` and panic if the converted value doesn't fit + | +LL | foo::<isize>(x_i32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:59:18 + | +LL | foo::<isize>(x_i16); + | ------------ ^^^^^ expected `isize`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to an `isize` + | +LL | foo::<isize>(x_i16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:61:18 + | +LL | foo::<isize>(x_i8); + | ------------ ^^^^ expected `isize`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to an `isize` + | +LL | foo::<isize>(x_i8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:66:16 + | +LL | foo::<u64>(x_usize); + | ---------- ^^^^^^^ expected `u64`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `usize` to a `u64` and panic if the converted value doesn't fit + | +LL | foo::<u64>(x_usize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:69:16 + | +LL | foo::<u64>(x_u32); + | ---------- ^^^^^ expected `u64`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to a `u64` + | +LL | foo::<u64>(x_u32.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:71:16 + | +LL | foo::<u64>(x_u16); + | ---------- ^^^^^ expected `u64`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to a `u64` + | +LL | foo::<u64>(x_u16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:73:16 + | +LL | foo::<u64>(x_u8); + | ---------- ^^^^ expected `u64`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to a `u64` + | +LL | foo::<u64>(x_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:75:16 + | +LL | foo::<u64>(x_isize); + | ---------- ^^^^^^^ expected `u64`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to a `u64` and panic if the converted value doesn't fit + | +LL | foo::<u64>(x_isize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:77:16 + | +LL | foo::<u64>(x_i64); + | ---------- ^^^^^ expected `u64`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to a `u64` and panic if the converted value doesn't fit + | +LL | foo::<u64>(x_i64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:79:16 + | +LL | foo::<u64>(x_i32); + | ---------- ^^^^^ expected `u64`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to a `u64` and panic if the converted value doesn't fit + | +LL | foo::<u64>(x_i32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:81:16 + | +LL | foo::<u64>(x_i16); + | ---------- ^^^^^ expected `u64`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to a `u64` and panic if the converted value doesn't fit + | +LL | foo::<u64>(x_i16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:83:16 + | +LL | foo::<u64>(x_i8); + | ---------- ^^^^ expected `u64`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to a `u64` and panic if the converted value doesn't fit + | +LL | foo::<u64>(x_i8.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:88:16 + | +LL | foo::<i64>(x_usize); + | ---------- ^^^^^^^ expected `i64`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `usize` to an `i64` and panic if the converted value doesn't fit + | +LL | foo::<i64>(x_usize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:90:16 + | +LL | foo::<i64>(x_u64); + | ---------- ^^^^^ expected `i64`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u64` to an `i64` and panic if the converted value doesn't fit + | +LL | foo::<i64>(x_u64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:92:16 + | +LL | foo::<i64>(x_u32); + | ---------- ^^^^^ expected `i64`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to an `i64` + | +LL | foo::<i64>(x_u32.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:94:16 + | +LL | foo::<i64>(x_u16); + | ---------- ^^^^^ expected `i64`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to an `i64` + | +LL | foo::<i64>(x_u16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:96:16 + | +LL | foo::<i64>(x_u8); + | ---------- ^^^^ expected `i64`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to an `i64` + | +LL | foo::<i64>(x_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:98:16 + | +LL | foo::<i64>(x_isize); + | ---------- ^^^^^^^ expected `i64`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to an `i64` and panic if the converted value doesn't fit + | +LL | foo::<i64>(x_isize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:101:16 + | +LL | foo::<i64>(x_i32); + | ---------- ^^^^^ expected `i64`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to an `i64` + | +LL | foo::<i64>(x_i32.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:103:16 + | +LL | foo::<i64>(x_i16); + | ---------- ^^^^^ expected `i64`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to an `i64` + | +LL | foo::<i64>(x_i16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:105:16 + | +LL | foo::<i64>(x_i8); + | ---------- ^^^^ expected `i64`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to an `i64` + | +LL | foo::<i64>(x_i8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:110:16 + | +LL | foo::<u32>(x_usize); + | ---------- ^^^^^^^ expected `u32`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `usize` to a `u32` and panic if the converted value doesn't fit + | +LL | foo::<u32>(x_usize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:112:16 + | +LL | foo::<u32>(x_u64); + | ---------- ^^^^^ expected `u32`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u64` to a `u32` and panic if the converted value doesn't fit + | +LL | foo::<u32>(x_u64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:115:16 + | +LL | foo::<u32>(x_u16); + | ---------- ^^^^^ expected `u32`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to a `u32` + | +LL | foo::<u32>(x_u16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:117:16 + | +LL | foo::<u32>(x_u8); + | ---------- ^^^^ expected `u32`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to a `u32` + | +LL | foo::<u32>(x_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:119:16 + | +LL | foo::<u32>(x_isize); + | ---------- ^^^^^^^ expected `u32`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to a `u32` and panic if the converted value doesn't fit + | +LL | foo::<u32>(x_isize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:121:16 + | +LL | foo::<u32>(x_i64); + | ---------- ^^^^^ expected `u32`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to a `u32` and panic if the converted value doesn't fit + | +LL | foo::<u32>(x_i64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:123:16 + | +LL | foo::<u32>(x_i32); + | ---------- ^^^^^ expected `u32`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to a `u32` and panic if the converted value doesn't fit + | +LL | foo::<u32>(x_i32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:125:16 + | +LL | foo::<u32>(x_i16); + | ---------- ^^^^^ expected `u32`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to a `u32` and panic if the converted value doesn't fit + | +LL | foo::<u32>(x_i16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:127:16 + | +LL | foo::<u32>(x_i8); + | ---------- ^^^^ expected `u32`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to a `u32` and panic if the converted value doesn't fit + | +LL | foo::<u32>(x_i8.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:132:16 + | +LL | foo::<i32>(x_usize); + | ---------- ^^^^^^^ expected `i32`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `usize` to an `i32` and panic if the converted value doesn't fit + | +LL | foo::<i32>(x_usize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:134:16 + | +LL | foo::<i32>(x_u64); + | ---------- ^^^^^ expected `i32`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u64` to an `i32` and panic if the converted value doesn't fit + | +LL | foo::<i32>(x_u64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:136:16 + | +LL | foo::<i32>(x_u32); + | ---------- ^^^^^ expected `i32`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to an `i32` and panic if the converted value doesn't fit + | +LL | foo::<i32>(x_u32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:138:16 + | +LL | foo::<i32>(x_u16); + | ---------- ^^^^^ expected `i32`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to an `i32` + | +LL | foo::<i32>(x_u16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:140:16 + | +LL | foo::<i32>(x_u8); + | ---------- ^^^^ expected `i32`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to an `i32` + | +LL | foo::<i32>(x_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:142:16 + | +LL | foo::<i32>(x_isize); + | ---------- ^^^^^^^ expected `i32`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to an `i32` and panic if the converted value doesn't fit + | +LL | foo::<i32>(x_isize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:144:16 + | +LL | foo::<i32>(x_i64); + | ---------- ^^^^^ expected `i32`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to an `i32` and panic if the converted value doesn't fit + | +LL | foo::<i32>(x_i64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:147:16 + | +LL | foo::<i32>(x_i16); + | ---------- ^^^^^ expected `i32`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to an `i32` + | +LL | foo::<i32>(x_i16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:149:16 + | +LL | foo::<i32>(x_i8); + | ---------- ^^^^ expected `i32`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to an `i32` + | +LL | foo::<i32>(x_i8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:154:16 + | +LL | foo::<u16>(x_usize); + | ---------- ^^^^^^^ expected `u16`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `usize` to a `u16` and panic if the converted value doesn't fit + | +LL | foo::<u16>(x_usize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:156:16 + | +LL | foo::<u16>(x_u64); + | ---------- ^^^^^ expected `u16`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u64` to a `u16` and panic if the converted value doesn't fit + | +LL | foo::<u16>(x_u64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:158:16 + | +LL | foo::<u16>(x_u32); + | ---------- ^^^^^ expected `u16`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to a `u16` and panic if the converted value doesn't fit + | +LL | foo::<u16>(x_u32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:161:16 + | +LL | foo::<u16>(x_u8); + | ---------- ^^^^ expected `u16`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to a `u16` + | +LL | foo::<u16>(x_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:163:16 + | +LL | foo::<u16>(x_isize); + | ---------- ^^^^^^^ expected `u16`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to a `u16` and panic if the converted value doesn't fit + | +LL | foo::<u16>(x_isize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:165:16 + | +LL | foo::<u16>(x_i64); + | ---------- ^^^^^ expected `u16`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to a `u16` and panic if the converted value doesn't fit + | +LL | foo::<u16>(x_i64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:167:16 + | +LL | foo::<u16>(x_i32); + | ---------- ^^^^^ expected `u16`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to a `u16` and panic if the converted value doesn't fit + | +LL | foo::<u16>(x_i32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:169:16 + | +LL | foo::<u16>(x_i16); + | ---------- ^^^^^ expected `u16`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to a `u16` and panic if the converted value doesn't fit + | +LL | foo::<u16>(x_i16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:171:16 + | +LL | foo::<u16>(x_i8); + | ---------- ^^^^ expected `u16`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to a `u16` and panic if the converted value doesn't fit + | +LL | foo::<u16>(x_i8.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:176:16 + | +LL | foo::<i16>(x_usize); + | ---------- ^^^^^^^ expected `i16`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `usize` to an `i16` and panic if the converted value doesn't fit + | +LL | foo::<i16>(x_usize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:178:16 + | +LL | foo::<i16>(x_u64); + | ---------- ^^^^^ expected `i16`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u64` to an `i16` and panic if the converted value doesn't fit + | +LL | foo::<i16>(x_u64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:180:16 + | +LL | foo::<i16>(x_u32); + | ---------- ^^^^^ expected `i16`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to an `i16` and panic if the converted value doesn't fit + | +LL | foo::<i16>(x_u32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:182:16 + | +LL | foo::<i16>(x_u16); + | ---------- ^^^^^ expected `i16`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to an `i16` and panic if the converted value doesn't fit + | +LL | foo::<i16>(x_u16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:184:16 + | +LL | foo::<i16>(x_u8); + | ---------- ^^^^ expected `i16`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to an `i16` + | +LL | foo::<i16>(x_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:186:16 + | +LL | foo::<i16>(x_isize); + | ---------- ^^^^^^^ expected `i16`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to an `i16` and panic if the converted value doesn't fit + | +LL | foo::<i16>(x_isize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:188:16 + | +LL | foo::<i16>(x_i64); + | ---------- ^^^^^ expected `i16`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to an `i16` and panic if the converted value doesn't fit + | +LL | foo::<i16>(x_i64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:190:16 + | +LL | foo::<i16>(x_i32); + | ---------- ^^^^^ expected `i16`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to an `i16` and panic if the converted value doesn't fit + | +LL | foo::<i16>(x_i32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:193:16 + | +LL | foo::<i16>(x_i8); + | ---------- ^^^^ expected `i16`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to an `i16` + | +LL | foo::<i16>(x_i8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:198:15 + | +LL | foo::<u8>(x_usize); + | --------- ^^^^^^^ expected `u8`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `usize` to a `u8` and panic if the converted value doesn't fit + | +LL | foo::<u8>(x_usize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:200:15 + | +LL | foo::<u8>(x_u64); + | --------- ^^^^^ expected `u8`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u64` to a `u8` and panic if the converted value doesn't fit + | +LL | foo::<u8>(x_u64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:202:15 + | +LL | foo::<u8>(x_u32); + | --------- ^^^^^ expected `u8`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to a `u8` and panic if the converted value doesn't fit + | +LL | foo::<u8>(x_u32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:204:15 + | +LL | foo::<u8>(x_u16); + | --------- ^^^^^ expected `u8`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to a `u8` and panic if the converted value doesn't fit + | +LL | foo::<u8>(x_u16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:207:15 + | +LL | foo::<u8>(x_isize); + | --------- ^^^^^^^ expected `u8`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to a `u8` and panic if the converted value doesn't fit + | +LL | foo::<u8>(x_isize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:209:15 + | +LL | foo::<u8>(x_i64); + | --------- ^^^^^ expected `u8`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to a `u8` and panic if the converted value doesn't fit + | +LL | foo::<u8>(x_i64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:211:15 + | +LL | foo::<u8>(x_i32); + | --------- ^^^^^ expected `u8`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to a `u8` and panic if the converted value doesn't fit + | +LL | foo::<u8>(x_i32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:213:15 + | +LL | foo::<u8>(x_i16); + | --------- ^^^^^ expected `u8`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to a `u8` and panic if the converted value doesn't fit + | +LL | foo::<u8>(x_i16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:215:15 + | +LL | foo::<u8>(x_i8); + | --------- ^^^^ expected `u8`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to a `u8` and panic if the converted value doesn't fit + | +LL | foo::<u8>(x_i8.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:220:15 + | +LL | foo::<i8>(x_usize); + | --------- ^^^^^^^ expected `i8`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `usize` to an `i8` and panic if the converted value doesn't fit + | +LL | foo::<i8>(x_usize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:222:15 + | +LL | foo::<i8>(x_u64); + | --------- ^^^^^ expected `i8`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u64` to an `i8` and panic if the converted value doesn't fit + | +LL | foo::<i8>(x_u64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:224:15 + | +LL | foo::<i8>(x_u32); + | --------- ^^^^^ expected `i8`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to an `i8` and panic if the converted value doesn't fit + | +LL | foo::<i8>(x_u32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:226:15 + | +LL | foo::<i8>(x_u16); + | --------- ^^^^^ expected `i8`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to an `i8` and panic if the converted value doesn't fit + | +LL | foo::<i8>(x_u16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:228:15 + | +LL | foo::<i8>(x_u8); + | --------- ^^^^ expected `i8`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to an `i8` and panic if the converted value doesn't fit + | +LL | foo::<i8>(x_u8.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:230:15 + | +LL | foo::<i8>(x_isize); + | --------- ^^^^^^^ expected `i8`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to an `i8` and panic if the converted value doesn't fit + | +LL | foo::<i8>(x_isize.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:232:15 + | +LL | foo::<i8>(x_i64); + | --------- ^^^^^ expected `i8`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to an `i8` and panic if the converted value doesn't fit + | +LL | foo::<i8>(x_i64.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:234:15 + | +LL | foo::<i8>(x_i32); + | --------- ^^^^^ expected `i8`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to an `i8` and panic if the converted value doesn't fit + | +LL | foo::<i8>(x_i32.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:236:15 + | +LL | foo::<i8>(x_i16); + | --------- ^^^^^ expected `i8`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to an `i8` and panic if the converted value doesn't fit + | +LL | foo::<i8>(x_i16.try_into().unwrap()); + | ++++++++++++++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:242:16 + | +LL | foo::<f64>(x_usize); + | ---------- ^^^^^^^ expected `f64`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can cast a `usize` to an `f64`, producing the floating point representation of the integer, rounded if necessary + | +LL | foo::<f64>(x_usize as f64); + | ++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:244:16 + | +LL | foo::<f64>(x_u64); + | ---------- ^^^^^ expected `f64`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can cast a `u64` to an `f64`, producing the floating point representation of the integer, rounded if necessary + | +LL | foo::<f64>(x_u64 as f64); + | ++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:246:16 + | +LL | foo::<f64>(x_u32); + | ---------- ^^^^^ expected `f64`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to an `f64`, producing the floating point representation of the integer + | +LL | foo::<f64>(x_u32.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:248:16 + | +LL | foo::<f64>(x_u16); + | ---------- ^^^^^ expected `f64`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to an `f64`, producing the floating point representation of the integer + | +LL | foo::<f64>(x_u16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:250:16 + | +LL | foo::<f64>(x_u8); + | ---------- ^^^^ expected `f64`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to an `f64`, producing the floating point representation of the integer + | +LL | foo::<f64>(x_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:252:16 + | +LL | foo::<f64>(x_isize); + | ---------- ^^^^^^^ expected `f64`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to an `f64`, producing the floating point representation of the integer, rounded if necessary + | +LL | foo::<f64>(x_isize as f64); + | ++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:254:16 + | +LL | foo::<f64>(x_i64); + | ---------- ^^^^^ expected `f64`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to an `f64`, producing the floating point representation of the integer, rounded if necessary + | +LL | foo::<f64>(x_i64 as f64); + | ++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:256:16 + | +LL | foo::<f64>(x_i32); + | ---------- ^^^^^ expected `f64`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to an `f64`, producing the floating point representation of the integer + | +LL | foo::<f64>(x_i32.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:258:16 + | +LL | foo::<f64>(x_i16); + | ---------- ^^^^^ expected `f64`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to an `f64`, producing the floating point representation of the integer + | +LL | foo::<f64>(x_i16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:260:16 + | +LL | foo::<f64>(x_i8); + | ---------- ^^^^ expected `f64`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to an `f64`, producing the floating point representation of the integer + | +LL | foo::<f64>(x_i8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:263:16 + | +LL | foo::<f64>(x_f32); + | ---------- ^^^^^ expected `f64`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `f32` to an `f64` + | +LL | foo::<f64>(x_f32.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:266:16 + | +LL | foo::<f32>(x_usize); + | ---------- ^^^^^^^ expected `f32`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can cast a `usize` to an `f32`, producing the floating point representation of the integer, rounded if necessary + | +LL | foo::<f32>(x_usize as f32); + | ++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:268:16 + | +LL | foo::<f32>(x_u64); + | ---------- ^^^^^ expected `f32`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can cast a `u64` to an `f32`, producing the floating point representation of the integer, rounded if necessary + | +LL | foo::<f32>(x_u64 as f32); + | ++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:270:16 + | +LL | foo::<f32>(x_u32); + | ---------- ^^^^^ expected `f32`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can cast a `u32` to an `f32`, producing the floating point representation of the integer, rounded if necessary + | +LL | foo::<f32>(x_u32 as f32); + | ++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:272:16 + | +LL | foo::<f32>(x_u16); + | ---------- ^^^^^ expected `f32`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to an `f32`, producing the floating point representation of the integer + | +LL | foo::<f32>(x_u16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:274:16 + | +LL | foo::<f32>(x_u8); + | ---------- ^^^^ expected `f32`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to an `f32`, producing the floating point representation of the integer + | +LL | foo::<f32>(x_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:276:16 + | +LL | foo::<f32>(x_isize); + | ---------- ^^^^^^^ expected `f32`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `isize` to an `f32`, producing the floating point representation of the integer, rounded if necessary + | +LL | foo::<f32>(x_isize as f32); + | ++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:278:16 + | +LL | foo::<f32>(x_i64); + | ---------- ^^^^^ expected `f32`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i64` to an `f32`, producing the floating point representation of the integer, rounded if necessary + | +LL | foo::<f32>(x_i64 as f32); + | ++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:280:16 + | +LL | foo::<f32>(x_i32); + | ---------- ^^^^^ expected `f32`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to an `f32`, producing the floating point representation of the integer, rounded if necessary + | +LL | foo::<f32>(x_i32 as f32); + | ++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:282:16 + | +LL | foo::<f32>(x_i16); + | ---------- ^^^^^ expected `f32`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to an `f32`, producing the floating point representation of the integer + | +LL | foo::<f32>(x_i16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:284:16 + | +LL | foo::<f32>(x_i8); + | ---------- ^^^^ expected `f32`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to an `f32`, producing the floating point representation of the integer + | +LL | foo::<f32>(x_i8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:289:16 + | +LL | foo::<u32>(x_u8 as u16); + | ---------- ^^^^^^^^^^^ expected `u32`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to a `u32` + | +LL | foo::<u32>((x_u8 as u16).into()); + | + ++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-cast.rs:291:16 + | +LL | foo::<i32>(-x_i8); + | ---------- ^^^^^ expected `i32`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-cast.rs:6:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to an `i32` + | +LL | foo::<i32>((-x_i8).into()); + | + ++++++++ + +error: aborting due to 113 previous errors + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/numeric/numeric-fields.rs b/src/test/ui/numeric/numeric-fields.rs new file mode 100644 index 000000000..28234bbdf --- /dev/null +++ b/src/test/ui/numeric/numeric-fields.rs @@ -0,0 +1,10 @@ +struct S(u8, u16); + +fn main() { + let s = S{0b1: 10, 0: 11}; + //~^ ERROR struct `S` has no field named `0b1` + match s { + S{0: a, 0x1: b, ..} => {} + //~^ ERROR does not have a field named `0x1` + } +} diff --git a/src/test/ui/numeric/numeric-fields.stderr b/src/test/ui/numeric/numeric-fields.stderr new file mode 100644 index 000000000..668405ed6 --- /dev/null +++ b/src/test/ui/numeric/numeric-fields.stderr @@ -0,0 +1,27 @@ +error[E0560]: struct `S` has no field named `0b1` + --> $DIR/numeric-fields.rs:4:15 + | +LL | struct S(u8, u16); + | - `S` defined here +... +LL | let s = S{0b1: 10, 0: 11}; + | ^^^ field does not exist + | +help: `S` is a tuple struct, use the appropriate syntax + | +LL | let s = S(/* fields */); + | ~~~~~~~~~~~~~~~ + +error[E0026]: struct `S` does not have a field named `0x1` + --> $DIR/numeric-fields.rs:7:17 + | +LL | S{0: a, 0x1: b, ..} => {} + | ^^^ + | | + | struct `S` does not have this field + | help: `S` has a field named `1` + +error: aborting due to 2 previous errors + +Some errors have detailed explanations: E0026, E0560. +For more information about an error, try `rustc --explain E0026`. diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.fixed b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.fixed new file mode 100644 index 000000000..6e8c54df4 --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.fixed @@ -0,0 +1,73 @@ +// run-rustfix + +fn foo<N>(_x: N) {} +//~^ NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE + +fn main() { + foo::<i32>(42_i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(42_i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(42_i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(42_i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(42_i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(42_i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(42_i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(42_i32); + foo::<i32>(42_i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(42_i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(42i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(42i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments +} diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.rs b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.rs new file mode 100644 index 000000000..b47b0ed02 --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.rs @@ -0,0 +1,73 @@ +// run-rustfix + +fn foo<N>(_x: N) {} +//~^ NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE + +fn main() { + foo::<i32>(42_usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(42_u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(42_u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(42_u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(42_u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(42_isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(42_i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(42_i32); + foo::<i32>(42_i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(42.0_f64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(42.0_f32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments +} diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.stderr b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.stderr new file mode 100644 index 000000000..f4fb14e79 --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.stderr @@ -0,0 +1,201 @@ +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i32.rs:28:16 + | +LL | foo::<i32>(42_usize); + | ---------- ^^^^^^^^ expected `i32`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `usize` to `i32` + | +LL | foo::<i32>(42_i32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i32.rs:32:16 + | +LL | foo::<i32>(42_u64); + | ---------- ^^^^^^ expected `i32`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u64` to `i32` + | +LL | foo::<i32>(42_i32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i32.rs:36:16 + | +LL | foo::<i32>(42_u32); + | ---------- ^^^^^^ expected `i32`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u32` to `i32` + | +LL | foo::<i32>(42_i32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i32.rs:40:16 + | +LL | foo::<i32>(42_u16); + | ---------- ^^^^^^ expected `i32`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u16` to `i32` + | +LL | foo::<i32>(42_i32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i32.rs:44:16 + | +LL | foo::<i32>(42_u8); + | ---------- ^^^^^ expected `i32`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u8` to `i32` + | +LL | foo::<i32>(42_i32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i32.rs:48:16 + | +LL | foo::<i32>(42_isize); + | ---------- ^^^^^^^^ expected `i32`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `isize` to `i32` + | +LL | foo::<i32>(42_i32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i32.rs:52:16 + | +LL | foo::<i32>(42_i64); + | ---------- ^^^^^^ expected `i32`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i64` to `i32` + | +LL | foo::<i32>(42_i32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i32.rs:57:16 + | +LL | foo::<i32>(42_i16); + | ---------- ^^^^^^ expected `i32`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i16` to `i32` + | +LL | foo::<i32>(42_i32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i32.rs:61:16 + | +LL | foo::<i32>(42_i8); + | ---------- ^^^^^ expected `i32`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i8` to `i32` + | +LL | foo::<i32>(42_i32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i32.rs:65:16 + | +LL | foo::<i32>(42.0_f64); + | ---------- ^^^^^^^^ expected `i32`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f64` to `i32` + | +LL | foo::<i32>(42i32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i32.rs:69:16 + | +LL | foo::<i32>(42.0_f32); + | ---------- ^^^^^^^^ expected `i32`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f32` to `i32` + | +LL | foo::<i32>(42i32); + | ~~~ + +error: aborting due to 11 previous errors + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.fixed b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.fixed new file mode 100644 index 000000000..03821cd44 --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.fixed @@ -0,0 +1,73 @@ +// run-rustfix + +fn foo<N>(_x: N) {} +//~^ NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE + +fn main() { + foo::<i64>(42_i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i64>(42_i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i64>(42_i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i64>(42_i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i64>(42_i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i64>(42_i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i64>(42_i64); + foo::<i64>(42_i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i64>(42_i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i64>(42_i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i64>(42i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i64>(42i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments +} diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.rs b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.rs new file mode 100644 index 000000000..629fe7e74 --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.rs @@ -0,0 +1,73 @@ +// run-rustfix + +fn foo<N>(_x: N) {} +//~^ NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE + +fn main() { + foo::<i64>(42_usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i64>(42_u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i64>(42_u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i64>(42_u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i64>(42_u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i64>(42_isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i64>(42_i64); + foo::<i64>(42_i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i64>(42_i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i64>(42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i64>(42.0_f64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i64>(42.0_f32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments +} diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.stderr b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.stderr new file mode 100644 index 000000000..47efe9f08 --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.stderr @@ -0,0 +1,201 @@ +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i64.rs:28:16 + | +LL | foo::<i64>(42_usize); + | ---------- ^^^^^^^^ expected `i64`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `usize` to `i64` + | +LL | foo::<i64>(42_i64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i64.rs:32:16 + | +LL | foo::<i64>(42_u64); + | ---------- ^^^^^^ expected `i64`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u64` to `i64` + | +LL | foo::<i64>(42_i64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i64.rs:36:16 + | +LL | foo::<i64>(42_u32); + | ---------- ^^^^^^ expected `i64`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u32` to `i64` + | +LL | foo::<i64>(42_i64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i64.rs:40:16 + | +LL | foo::<i64>(42_u16); + | ---------- ^^^^^^ expected `i64`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u16` to `i64` + | +LL | foo::<i64>(42_i64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i64.rs:44:16 + | +LL | foo::<i64>(42_u8); + | ---------- ^^^^^ expected `i64`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u8` to `i64` + | +LL | foo::<i64>(42_i64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i64.rs:48:16 + | +LL | foo::<i64>(42_isize); + | ---------- ^^^^^^^^ expected `i64`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `isize` to `i64` + | +LL | foo::<i64>(42_i64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i64.rs:53:16 + | +LL | foo::<i64>(42_i32); + | ---------- ^^^^^^ expected `i64`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i32` to `i64` + | +LL | foo::<i64>(42_i64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i64.rs:57:16 + | +LL | foo::<i64>(42_i16); + | ---------- ^^^^^^ expected `i64`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i16` to `i64` + | +LL | foo::<i64>(42_i64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i64.rs:61:16 + | +LL | foo::<i64>(42_i8); + | ---------- ^^^^^ expected `i64`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i8` to `i64` + | +LL | foo::<i64>(42_i64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i64.rs:65:16 + | +LL | foo::<i64>(42.0_f64); + | ---------- ^^^^^^^^ expected `i64`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f64` to `i64` + | +LL | foo::<i64>(42i64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-i64.rs:69:16 + | +LL | foo::<i64>(42.0_f32); + | ---------- ^^^^^^^^ expected `i64`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-i64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f32` to `i64` + | +LL | foo::<i64>(42i64); + | ~~~ + +error: aborting due to 11 previous errors + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.fixed b/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.fixed new file mode 100644 index 000000000..faed65ca4 --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.fixed @@ -0,0 +1,73 @@ +// run-rustfix + +fn foo<N>(_x: N) {} +//~^ NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE + +fn main() { + foo::<isize>(42_isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<isize>(42_isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<isize>(42_isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<isize>(42_isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<isize>(42_isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<isize>(42_isize); + foo::<isize>(42_isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<isize>(42_isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<isize>(42_isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<isize>(42_isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<isize>(42isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<isize>(42isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments +} diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.rs b/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.rs new file mode 100644 index 000000000..df0b4cb62 --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.rs @@ -0,0 +1,73 @@ +// run-rustfix + +fn foo<N>(_x: N) {} +//~^ NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE + +fn main() { + foo::<isize>(42_usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<isize>(42_u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<isize>(42_u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<isize>(42_u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<isize>(42_u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<isize>(42_isize); + foo::<isize>(42_i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<isize>(42_i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<isize>(42_i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<isize>(42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<isize>(42.0_f64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<isize>(42.0_f32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments +} diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.stderr b/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.stderr new file mode 100644 index 000000000..28b79413f --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.stderr @@ -0,0 +1,201 @@ +error[E0308]: mismatched types + --> $DIR/numeric-suffix-isize.rs:28:18 + | +LL | foo::<isize>(42_usize); + | ------------ ^^^^^^^^ expected `isize`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-isize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `usize` to `isize` + | +LL | foo::<isize>(42_isize); + | ~~~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-isize.rs:32:18 + | +LL | foo::<isize>(42_u64); + | ------------ ^^^^^^ expected `isize`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-isize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u64` to `isize` + | +LL | foo::<isize>(42_isize); + | ~~~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-isize.rs:36:18 + | +LL | foo::<isize>(42_u32); + | ------------ ^^^^^^ expected `isize`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-isize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u32` to `isize` + | +LL | foo::<isize>(42_isize); + | ~~~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-isize.rs:40:18 + | +LL | foo::<isize>(42_u16); + | ------------ ^^^^^^ expected `isize`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-isize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u16` to `isize` + | +LL | foo::<isize>(42_isize); + | ~~~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-isize.rs:44:18 + | +LL | foo::<isize>(42_u8); + | ------------ ^^^^^ expected `isize`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-isize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u8` to `isize` + | +LL | foo::<isize>(42_isize); + | ~~~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-isize.rs:49:18 + | +LL | foo::<isize>(42_i64); + | ------------ ^^^^^^ expected `isize`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-isize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i64` to `isize` + | +LL | foo::<isize>(42_isize); + | ~~~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-isize.rs:53:18 + | +LL | foo::<isize>(42_i32); + | ------------ ^^^^^^ expected `isize`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-isize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i32` to `isize` + | +LL | foo::<isize>(42_isize); + | ~~~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-isize.rs:57:18 + | +LL | foo::<isize>(42_i16); + | ------------ ^^^^^^ expected `isize`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-isize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i16` to `isize` + | +LL | foo::<isize>(42_isize); + | ~~~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-isize.rs:61:18 + | +LL | foo::<isize>(42_i8); + | ------------ ^^^^^ expected `isize`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-isize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i8` to `isize` + | +LL | foo::<isize>(42_isize); + | ~~~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-isize.rs:65:18 + | +LL | foo::<isize>(42.0_f64); + | ------------ ^^^^^^^^ expected `isize`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-isize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f64` to `isize` + | +LL | foo::<isize>(42isize); + | ~~~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-isize.rs:69:18 + | +LL | foo::<isize>(42.0_f32); + | ------------ ^^^^^^^^ expected `isize`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-isize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f32` to `isize` + | +LL | foo::<isize>(42isize); + | ~~~~~ + +error: aborting due to 11 previous errors + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.fixed b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.fixed new file mode 100644 index 000000000..5955829e7 --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.fixed @@ -0,0 +1,73 @@ +// run-rustfix + +fn foo<N>(_x: N) {} +//~^ NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE + +fn main() { + foo::<u32>(42_u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u32>(42_u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u32>(42_u32); + foo::<u32>(42_u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u32>(42_u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u32>(42_u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u32>(42_u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u32>(42_u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u32>(42_u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u32>(42_u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u32>(42u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u32>(42u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments +} diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.rs b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.rs new file mode 100644 index 000000000..5c303036a --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.rs @@ -0,0 +1,73 @@ +// run-rustfix + +fn foo<N>(_x: N) {} +//~^ NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE + +fn main() { + foo::<u32>(42_usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u32>(42_u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u32>(42_u32); + foo::<u32>(42_u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u32>(42_u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u32>(42_isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u32>(42_i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u32>(42_i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u32>(42_i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u32>(42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u32>(42.0_f64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u32>(42.0_f32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments +} diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.stderr b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.stderr new file mode 100644 index 000000000..d966893a8 --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.stderr @@ -0,0 +1,201 @@ +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u32.rs:28:16 + | +LL | foo::<u32>(42_usize); + | ---------- ^^^^^^^^ expected `u32`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `usize` to `u32` + | +LL | foo::<u32>(42_u32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u32.rs:32:16 + | +LL | foo::<u32>(42_u64); + | ---------- ^^^^^^ expected `u32`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u64` to `u32` + | +LL | foo::<u32>(42_u32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u32.rs:37:16 + | +LL | foo::<u32>(42_u16); + | ---------- ^^^^^^ expected `u32`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u16` to `u32` + | +LL | foo::<u32>(42_u32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u32.rs:41:16 + | +LL | foo::<u32>(42_u8); + | ---------- ^^^^^ expected `u32`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u8` to `u32` + | +LL | foo::<u32>(42_u32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u32.rs:45:16 + | +LL | foo::<u32>(42_isize); + | ---------- ^^^^^^^^ expected `u32`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `isize` to `u32` + | +LL | foo::<u32>(42_u32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u32.rs:49:16 + | +LL | foo::<u32>(42_i64); + | ---------- ^^^^^^ expected `u32`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i64` to `u32` + | +LL | foo::<u32>(42_u32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u32.rs:53:16 + | +LL | foo::<u32>(42_i32); + | ---------- ^^^^^^ expected `u32`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i32` to `u32` + | +LL | foo::<u32>(42_u32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u32.rs:57:16 + | +LL | foo::<u32>(42_i16); + | ---------- ^^^^^^ expected `u32`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i16` to `u32` + | +LL | foo::<u32>(42_u32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u32.rs:61:16 + | +LL | foo::<u32>(42_i8); + | ---------- ^^^^^ expected `u32`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i8` to `u32` + | +LL | foo::<u32>(42_u32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u32.rs:65:16 + | +LL | foo::<u32>(42.0_f64); + | ---------- ^^^^^^^^ expected `u32`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f64` to `u32` + | +LL | foo::<u32>(42u32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u32.rs:69:16 + | +LL | foo::<u32>(42.0_f32); + | ---------- ^^^^^^^^ expected `u32`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u32.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f32` to `u32` + | +LL | foo::<u32>(42u32); + | ~~~ + +error: aborting due to 11 previous errors + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.fixed b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.fixed new file mode 100644 index 000000000..4623c211c --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.fixed @@ -0,0 +1,73 @@ +// run-rustfix + +fn foo<N>(_x: N) {} +//~^ NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE + +fn main() { + foo::<u64>(42_u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u64>(42_u64); + foo::<u64>(42_u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u64>(42_u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u64>(42_u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u64>(42_u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u64>(42_u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u64>(42_u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u64>(42_u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u64>(42_u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u64>(42u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u64>(42u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments +} diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.rs b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.rs new file mode 100644 index 000000000..3e9995c74 --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.rs @@ -0,0 +1,73 @@ +// run-rustfix + +fn foo<N>(_x: N) {} +//~^ NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE + +fn main() { + foo::<u64>(42_usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u64>(42_u64); + foo::<u64>(42_u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u64>(42_u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u64>(42_u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u64>(42_isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u64>(42_i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u64>(42_i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u64>(42_i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u64>(42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u64>(42.0_f64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u64>(42.0_f32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments +} diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.stderr b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.stderr new file mode 100644 index 000000000..ff332fa91 --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.stderr @@ -0,0 +1,201 @@ +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u64.rs:28:16 + | +LL | foo::<u64>(42_usize); + | ---------- ^^^^^^^^ expected `u64`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `usize` to `u64` + | +LL | foo::<u64>(42_u64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u64.rs:33:16 + | +LL | foo::<u64>(42_u32); + | ---------- ^^^^^^ expected `u64`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u32` to `u64` + | +LL | foo::<u64>(42_u64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u64.rs:37:16 + | +LL | foo::<u64>(42_u16); + | ---------- ^^^^^^ expected `u64`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u16` to `u64` + | +LL | foo::<u64>(42_u64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u64.rs:41:16 + | +LL | foo::<u64>(42_u8); + | ---------- ^^^^^ expected `u64`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u8` to `u64` + | +LL | foo::<u64>(42_u64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u64.rs:45:16 + | +LL | foo::<u64>(42_isize); + | ---------- ^^^^^^^^ expected `u64`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `isize` to `u64` + | +LL | foo::<u64>(42_u64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u64.rs:49:16 + | +LL | foo::<u64>(42_i64); + | ---------- ^^^^^^ expected `u64`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i64` to `u64` + | +LL | foo::<u64>(42_u64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u64.rs:53:16 + | +LL | foo::<u64>(42_i32); + | ---------- ^^^^^^ expected `u64`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i32` to `u64` + | +LL | foo::<u64>(42_u64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u64.rs:57:16 + | +LL | foo::<u64>(42_i16); + | ---------- ^^^^^^ expected `u64`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i16` to `u64` + | +LL | foo::<u64>(42_u64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u64.rs:61:16 + | +LL | foo::<u64>(42_i8); + | ---------- ^^^^^ expected `u64`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i8` to `u64` + | +LL | foo::<u64>(42_u64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u64.rs:65:16 + | +LL | foo::<u64>(42.0_f64); + | ---------- ^^^^^^^^ expected `u64`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f64` to `u64` + | +LL | foo::<u64>(42u64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-u64.rs:69:16 + | +LL | foo::<u64>(42.0_f32); + | ---------- ^^^^^^^^ expected `u64`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-u64.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f32` to `u64` + | +LL | foo::<u64>(42u64); + | ~~~ + +error: aborting due to 11 previous errors + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.fixed b/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.fixed new file mode 100644 index 000000000..6cb5243ca --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.fixed @@ -0,0 +1,73 @@ +// run-rustfix + +fn foo<N>(_x: N) {} +//~^ NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE + +fn main() { + foo::<usize>(42_usize); + foo::<usize>(42_usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<usize>(42_usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<usize>(42_usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<usize>(42_usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<usize>(42_usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<usize>(42_usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<usize>(42_usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<usize>(42_usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<usize>(42_usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<usize>(42usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<usize>(42usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments +} diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.rs b/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.rs new file mode 100644 index 000000000..a2304ba26 --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.rs @@ -0,0 +1,73 @@ +// run-rustfix + +fn foo<N>(_x: N) {} +//~^ NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE + +fn main() { + foo::<usize>(42_usize); + foo::<usize>(42_u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<usize>(42_u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<usize>(42_u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<usize>(42_u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<usize>(42_isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<usize>(42_i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<usize>(42_i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<usize>(42_i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<usize>(42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<usize>(42.0_f64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<usize>(42.0_f32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments +} diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.stderr b/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.stderr new file mode 100644 index 000000000..4889abee6 --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.stderr @@ -0,0 +1,201 @@ +error[E0308]: mismatched types + --> $DIR/numeric-suffix-usize.rs:29:18 + | +LL | foo::<usize>(42_u64); + | ------------ ^^^^^^ expected `usize`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-usize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u64` to `usize` + | +LL | foo::<usize>(42_usize); + | ~~~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-usize.rs:33:18 + | +LL | foo::<usize>(42_u32); + | ------------ ^^^^^^ expected `usize`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-usize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u32` to `usize` + | +LL | foo::<usize>(42_usize); + | ~~~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-usize.rs:37:18 + | +LL | foo::<usize>(42_u16); + | ------------ ^^^^^^ expected `usize`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-usize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u16` to `usize` + | +LL | foo::<usize>(42_usize); + | ~~~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-usize.rs:41:18 + | +LL | foo::<usize>(42_u8); + | ------------ ^^^^^ expected `usize`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-usize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u8` to `usize` + | +LL | foo::<usize>(42_usize); + | ~~~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-usize.rs:45:18 + | +LL | foo::<usize>(42_isize); + | ------------ ^^^^^^^^ expected `usize`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-usize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `isize` to `usize` + | +LL | foo::<usize>(42_usize); + | ~~~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-usize.rs:49:18 + | +LL | foo::<usize>(42_i64); + | ------------ ^^^^^^ expected `usize`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-usize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i64` to `usize` + | +LL | foo::<usize>(42_usize); + | ~~~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-usize.rs:53:18 + | +LL | foo::<usize>(42_i32); + | ------------ ^^^^^^ expected `usize`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-usize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i32` to `usize` + | +LL | foo::<usize>(42_usize); + | ~~~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-usize.rs:57:18 + | +LL | foo::<usize>(42_i16); + | ------------ ^^^^^^ expected `usize`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-usize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i16` to `usize` + | +LL | foo::<usize>(42_usize); + | ~~~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-usize.rs:61:18 + | +LL | foo::<usize>(42_i8); + | ------------ ^^^^^ expected `usize`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-usize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i8` to `usize` + | +LL | foo::<usize>(42_usize); + | ~~~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-usize.rs:65:18 + | +LL | foo::<usize>(42.0_f64); + | ------------ ^^^^^^^^ expected `usize`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-usize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f64` to `usize` + | +LL | foo::<usize>(42usize); + | ~~~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix-usize.rs:69:18 + | +LL | foo::<usize>(42.0_f32); + | ------------ ^^^^^^^^ expected `usize`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix-usize.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f32` to `usize` + | +LL | foo::<usize>(42usize); + | ~~~~~ + +error: aborting due to 11 previous errors + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix.fixed b/src/test/ui/numeric/numeric-suffix/numeric-suffix.fixed new file mode 100644 index 000000000..69934db21 --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix.fixed @@ -0,0 +1,427 @@ +// run-rustfix + +fn foo<N>(_x: N) {} +//~^ NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE + + +fn main() { + foo::<u16>(42_u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u16>(42_u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u16>(42_u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u16>(42_u16); + foo::<u16>(42_u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u16>(42_u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u16>(42_u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u16>(42_u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u16>(42_u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u16>(42_u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u16>(42u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u16>(42u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + + foo::<i16>(42_i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i16>(42_i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i16>(42_i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i16>(42_i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i16>(42_i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i16>(42_i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i16>(42_i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i16>(42_i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i16>(42_i16); + foo::<i16>(42_i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i16>(42i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i16>(42i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + + foo::<u8>(42_u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u8>(42_u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u8>(42_u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u8>(42_u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u8>(42_u8); + foo::<u8>(42_u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u8>(42_u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u8>(42_u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u8>(42_u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u8>(42_u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u8>(42u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u8>(42u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + + foo::<i8>(42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i8>(42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i8>(42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i8>(42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i8>(42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i8>(42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i8>(42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i8>(42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i8>(42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i8>(42_i8); + foo::<i8>(42i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i8>(42i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + + foo::<f64>(42_f64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f64>(42_f64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f64>(42_u32.into()); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f64>(42_u16.into()); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f64>(42_u8.into()); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f64>(42_f64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f64>(42_f64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f64>(42_i32.into()); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f64>(42_i16.into()); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f64>(42_i8.into()); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f64>(42.0_f64); + foo::<f64>(42.0_f64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + + foo::<f32>(42_f32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42_f32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42_f32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42_u16.into()); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42_u8.into()); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42_f32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42_f32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42_f32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42_i16.into()); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42_i8.into()); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42.0_f32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42.0_f32); + + foo::<u32>((42_u8 as u16).into()); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>((-42_i8).into()); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments +} diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix.rs b/src/test/ui/numeric/numeric-suffix/numeric-suffix.rs new file mode 100644 index 000000000..dabf43f82 --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix.rs @@ -0,0 +1,427 @@ +// run-rustfix + +fn foo<N>(_x: N) {} +//~^ NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE function defined here +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE +//~| NOTE + + +fn main() { + foo::<u16>(42_usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u16>(42_u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u16>(42_u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u16>(42_u16); + foo::<u16>(42_u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u16>(42_isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u16>(42_i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u16>(42_i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u16>(42_i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u16>(42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u16>(42.0_f64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u16>(42.0_f32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + + foo::<i16>(42_usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i16>(42_u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i16>(42_u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i16>(42_u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i16>(42_u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i16>(42_isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i16>(42_i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i16>(42_i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i16>(42_i16); + foo::<i16>(42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i16>(42.0_f64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i16>(42.0_f32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + + foo::<u8>(42_usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u8>(42_u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u8>(42_u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u8>(42_u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u8>(42_u8); + foo::<u8>(42_isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u8>(42_i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u8>(42_i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u8>(42_i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u8>(42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u8>(42.0_f64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<u8>(42.0_f32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + + foo::<i8>(42_usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i8>(42_u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i8>(42_u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i8>(42_u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i8>(42_u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i8>(42_isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i8>(42_i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i8>(42_i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i8>(42_i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i8>(42_i8); + foo::<i8>(42.0_f64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i8>(42.0_f32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + + foo::<f64>(42_usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f64>(42_u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f64>(42_u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f64>(42_u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f64>(42_u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f64>(42_isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f64>(42_i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f64>(42_i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f64>(42_i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f64>(42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f64>(42.0_f64); + foo::<f64>(42.0_f32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + + foo::<f32>(42_usize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42_u64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42_u32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42_u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42_u8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42_isize); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42_i64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42_i32); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42_i16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42.0_f64); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<f32>(42.0_f32); + + foo::<u32>(42_u8 as u16); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments + foo::<i32>(-42_i8); + //~^ ERROR mismatched types + //~| NOTE expected + //~| NOTE arguments +} diff --git a/src/test/ui/numeric/numeric-suffix/numeric-suffix.stderr b/src/test/ui/numeric/numeric-suffix/numeric-suffix.stderr new file mode 100644 index 000000000..e05913b9c --- /dev/null +++ b/src/test/ui/numeric/numeric-suffix/numeric-suffix.stderr @@ -0,0 +1,1227 @@ +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:143:16 + | +LL | foo::<u16>(42_usize); + | ---------- ^^^^^^^^ expected `u16`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `usize` to `u16` + | +LL | foo::<u16>(42_u16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:147:16 + | +LL | foo::<u16>(42_u64); + | ---------- ^^^^^^ expected `u16`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u64` to `u16` + | +LL | foo::<u16>(42_u16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:151:16 + | +LL | foo::<u16>(42_u32); + | ---------- ^^^^^^ expected `u16`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u32` to `u16` + | +LL | foo::<u16>(42_u16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:156:16 + | +LL | foo::<u16>(42_u8); + | ---------- ^^^^^ expected `u16`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u8` to `u16` + | +LL | foo::<u16>(42_u16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:160:16 + | +LL | foo::<u16>(42_isize); + | ---------- ^^^^^^^^ expected `u16`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `isize` to `u16` + | +LL | foo::<u16>(42_u16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:164:16 + | +LL | foo::<u16>(42_i64); + | ---------- ^^^^^^ expected `u16`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i64` to `u16` + | +LL | foo::<u16>(42_u16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:168:16 + | +LL | foo::<u16>(42_i32); + | ---------- ^^^^^^ expected `u16`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i32` to `u16` + | +LL | foo::<u16>(42_u16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:172:16 + | +LL | foo::<u16>(42_i16); + | ---------- ^^^^^^ expected `u16`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i16` to `u16` + | +LL | foo::<u16>(42_u16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:176:16 + | +LL | foo::<u16>(42_i8); + | ---------- ^^^^^ expected `u16`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i8` to `u16` + | +LL | foo::<u16>(42_u16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:180:16 + | +LL | foo::<u16>(42.0_f64); + | ---------- ^^^^^^^^ expected `u16`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f64` to `u16` + | +LL | foo::<u16>(42u16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:184:16 + | +LL | foo::<u16>(42.0_f32); + | ---------- ^^^^^^^^ expected `u16`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f32` to `u16` + | +LL | foo::<u16>(42u16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:189:16 + | +LL | foo::<i16>(42_usize); + | ---------- ^^^^^^^^ expected `i16`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `usize` to `i16` + | +LL | foo::<i16>(42_i16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:193:16 + | +LL | foo::<i16>(42_u64); + | ---------- ^^^^^^ expected `i16`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u64` to `i16` + | +LL | foo::<i16>(42_i16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:197:16 + | +LL | foo::<i16>(42_u32); + | ---------- ^^^^^^ expected `i16`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u32` to `i16` + | +LL | foo::<i16>(42_i16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:201:16 + | +LL | foo::<i16>(42_u16); + | ---------- ^^^^^^ expected `i16`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u16` to `i16` + | +LL | foo::<i16>(42_i16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:205:16 + | +LL | foo::<i16>(42_u8); + | ---------- ^^^^^ expected `i16`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u8` to `i16` + | +LL | foo::<i16>(42_i16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:209:16 + | +LL | foo::<i16>(42_isize); + | ---------- ^^^^^^^^ expected `i16`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `isize` to `i16` + | +LL | foo::<i16>(42_i16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:213:16 + | +LL | foo::<i16>(42_i64); + | ---------- ^^^^^^ expected `i16`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i64` to `i16` + | +LL | foo::<i16>(42_i16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:217:16 + | +LL | foo::<i16>(42_i32); + | ---------- ^^^^^^ expected `i16`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i32` to `i16` + | +LL | foo::<i16>(42_i16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:222:16 + | +LL | foo::<i16>(42_i8); + | ---------- ^^^^^ expected `i16`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i8` to `i16` + | +LL | foo::<i16>(42_i16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:226:16 + | +LL | foo::<i16>(42.0_f64); + | ---------- ^^^^^^^^ expected `i16`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f64` to `i16` + | +LL | foo::<i16>(42i16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:230:16 + | +LL | foo::<i16>(42.0_f32); + | ---------- ^^^^^^^^ expected `i16`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f32` to `i16` + | +LL | foo::<i16>(42i16); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:235:15 + | +LL | foo::<u8>(42_usize); + | --------- ^^^^^^^^ expected `u8`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `usize` to `u8` + | +LL | foo::<u8>(42_u8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:239:15 + | +LL | foo::<u8>(42_u64); + | --------- ^^^^^^ expected `u8`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u64` to `u8` + | +LL | foo::<u8>(42_u8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:243:15 + | +LL | foo::<u8>(42_u32); + | --------- ^^^^^^ expected `u8`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u32` to `u8` + | +LL | foo::<u8>(42_u8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:247:15 + | +LL | foo::<u8>(42_u16); + | --------- ^^^^^^ expected `u8`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u16` to `u8` + | +LL | foo::<u8>(42_u8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:252:15 + | +LL | foo::<u8>(42_isize); + | --------- ^^^^^^^^ expected `u8`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `isize` to `u8` + | +LL | foo::<u8>(42_u8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:256:15 + | +LL | foo::<u8>(42_i64); + | --------- ^^^^^^ expected `u8`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i64` to `u8` + | +LL | foo::<u8>(42_u8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:260:15 + | +LL | foo::<u8>(42_i32); + | --------- ^^^^^^ expected `u8`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i32` to `u8` + | +LL | foo::<u8>(42_u8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:264:15 + | +LL | foo::<u8>(42_i16); + | --------- ^^^^^^ expected `u8`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i16` to `u8` + | +LL | foo::<u8>(42_u8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:268:15 + | +LL | foo::<u8>(42_i8); + | --------- ^^^^^ expected `u8`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i8` to `u8` + | +LL | foo::<u8>(42_u8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:272:15 + | +LL | foo::<u8>(42.0_f64); + | --------- ^^^^^^^^ expected `u8`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f64` to `u8` + | +LL | foo::<u8>(42u8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:276:15 + | +LL | foo::<u8>(42.0_f32); + | --------- ^^^^^^^^ expected `u8`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f32` to `u8` + | +LL | foo::<u8>(42u8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:281:15 + | +LL | foo::<i8>(42_usize); + | --------- ^^^^^^^^ expected `i8`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `usize` to `i8` + | +LL | foo::<i8>(42_i8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:285:15 + | +LL | foo::<i8>(42_u64); + | --------- ^^^^^^ expected `i8`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u64` to `i8` + | +LL | foo::<i8>(42_i8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:289:15 + | +LL | foo::<i8>(42_u32); + | --------- ^^^^^^ expected `i8`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u32` to `i8` + | +LL | foo::<i8>(42_i8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:293:15 + | +LL | foo::<i8>(42_u16); + | --------- ^^^^^^ expected `i8`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u16` to `i8` + | +LL | foo::<i8>(42_i8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:297:15 + | +LL | foo::<i8>(42_u8); + | --------- ^^^^^ expected `i8`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u8` to `i8` + | +LL | foo::<i8>(42_i8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:301:15 + | +LL | foo::<i8>(42_isize); + | --------- ^^^^^^^^ expected `i8`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `isize` to `i8` + | +LL | foo::<i8>(42_i8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:305:15 + | +LL | foo::<i8>(42_i64); + | --------- ^^^^^^ expected `i8`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i64` to `i8` + | +LL | foo::<i8>(42_i8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:309:15 + | +LL | foo::<i8>(42_i32); + | --------- ^^^^^^ expected `i8`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i32` to `i8` + | +LL | foo::<i8>(42_i8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:313:15 + | +LL | foo::<i8>(42_i16); + | --------- ^^^^^^ expected `i8`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i16` to `i8` + | +LL | foo::<i8>(42_i8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:318:15 + | +LL | foo::<i8>(42.0_f64); + | --------- ^^^^^^^^ expected `i8`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f64` to `i8` + | +LL | foo::<i8>(42i8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:322:15 + | +LL | foo::<i8>(42.0_f32); + | --------- ^^^^^^^^ expected `i8`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f32` to `i8` + | +LL | foo::<i8>(42i8); + | ~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:327:16 + | +LL | foo::<f64>(42_usize); + | ---------- ^^^^^^^^ expected `f64`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `usize` to `f64` + | +LL | foo::<f64>(42_f64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:331:16 + | +LL | foo::<f64>(42_u64); + | ---------- ^^^^^^ expected `f64`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u64` to `f64` + | +LL | foo::<f64>(42_f64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:335:16 + | +LL | foo::<f64>(42_u32); + | ---------- ^^^^^^ expected `f64`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u32` to an `f64`, producing the floating point representation of the integer + | +LL | foo::<f64>(42_u32.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:339:16 + | +LL | foo::<f64>(42_u16); + | ---------- ^^^^^^ expected `f64`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to an `f64`, producing the floating point representation of the integer + | +LL | foo::<f64>(42_u16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:343:16 + | +LL | foo::<f64>(42_u8); + | ---------- ^^^^^ expected `f64`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to an `f64`, producing the floating point representation of the integer + | +LL | foo::<f64>(42_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:347:16 + | +LL | foo::<f64>(42_isize); + | ---------- ^^^^^^^^ expected `f64`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `isize` to `f64` + | +LL | foo::<f64>(42_f64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:351:16 + | +LL | foo::<f64>(42_i64); + | ---------- ^^^^^^ expected `f64`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i64` to `f64` + | +LL | foo::<f64>(42_f64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:355:16 + | +LL | foo::<f64>(42_i32); + | ---------- ^^^^^^ expected `f64`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i32` to an `f64`, producing the floating point representation of the integer + | +LL | foo::<f64>(42_i32.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:359:16 + | +LL | foo::<f64>(42_i16); + | ---------- ^^^^^^ expected `f64`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to an `f64`, producing the floating point representation of the integer + | +LL | foo::<f64>(42_i16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:363:16 + | +LL | foo::<f64>(42_i8); + | ---------- ^^^^^ expected `f64`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to an `f64`, producing the floating point representation of the integer + | +LL | foo::<f64>(42_i8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:368:16 + | +LL | foo::<f64>(42.0_f32); + | ---------- ^^^^^^^^ expected `f64`, found `f32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f32` to `f64` + | +LL | foo::<f64>(42.0_f64); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:373:16 + | +LL | foo::<f32>(42_usize); + | ---------- ^^^^^^^^ expected `f32`, found `usize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `usize` to `f32` + | +LL | foo::<f32>(42_f32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:377:16 + | +LL | foo::<f32>(42_u64); + | ---------- ^^^^^^ expected `f32`, found `u64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u64` to `f32` + | +LL | foo::<f32>(42_f32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:381:16 + | +LL | foo::<f32>(42_u32); + | ---------- ^^^^^^ expected `f32`, found `u32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `u32` to `f32` + | +LL | foo::<f32>(42_f32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:385:16 + | +LL | foo::<f32>(42_u16); + | ---------- ^^^^^^ expected `f32`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to an `f32`, producing the floating point representation of the integer + | +LL | foo::<f32>(42_u16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:389:16 + | +LL | foo::<f32>(42_u8); + | ---------- ^^^^^ expected `f32`, found `u8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u8` to an `f32`, producing the floating point representation of the integer + | +LL | foo::<f32>(42_u8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:393:16 + | +LL | foo::<f32>(42_isize); + | ---------- ^^^^^^^^ expected `f32`, found `isize` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `isize` to `f32` + | +LL | foo::<f32>(42_f32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:397:16 + | +LL | foo::<f32>(42_i64); + | ---------- ^^^^^^ expected `f32`, found `i64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i64` to `f32` + | +LL | foo::<f32>(42_f32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:401:16 + | +LL | foo::<f32>(42_i32); + | ---------- ^^^^^^ expected `f32`, found `i32` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `i32` to `f32` + | +LL | foo::<f32>(42_f32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:405:16 + | +LL | foo::<f32>(42_i16); + | ---------- ^^^^^^ expected `f32`, found `i16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i16` to an `f32`, producing the floating point representation of the integer + | +LL | foo::<f32>(42_i16.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:409:16 + | +LL | foo::<f32>(42_i8); + | ---------- ^^^^^ expected `f32`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to an `f32`, producing the floating point representation of the integer + | +LL | foo::<f32>(42_i8.into()); + | +++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:413:16 + | +LL | foo::<f32>(42.0_f64); + | ---------- ^^^^^^^^ expected `f32`, found `f64` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: change the type of the numeric literal from `f64` to `f32` + | +LL | foo::<f32>(42.0_f32); + | ~~~ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:419:16 + | +LL | foo::<u32>(42_u8 as u16); + | ---------- ^^^^^^^^^^^^ expected `u32`, found `u16` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert a `u16` to a `u32` + | +LL | foo::<u32>((42_u8 as u16).into()); + | + ++++++++ + +error[E0308]: mismatched types + --> $DIR/numeric-suffix.rs:423:16 + | +LL | foo::<i32>(-42_i8); + | ---------- ^^^^^^ expected `i32`, found `i8` + | | + | arguments to this function are incorrect + | +note: function defined here + --> $DIR/numeric-suffix.rs:3:4 + | +LL | fn foo<N>(_x: N) {} + | ^^^ ----- +help: you can convert an `i8` to an `i32` + | +LL | foo::<i32>((-42_i8).into()); + | + ++++++++ + +error: aborting due to 68 previous errors + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/numeric/uppercase-base-prefix.fixed b/src/test/ui/numeric/uppercase-base-prefix.fixed new file mode 100644 index 000000000..1b1c837ec --- /dev/null +++ b/src/test/ui/numeric/uppercase-base-prefix.fixed @@ -0,0 +1,77 @@ +// run-rustfix +// Checks that integers with an uppercase base prefix (0B, 0X, 0O) have a nice error +#![allow(unused_variables)] + +fn main() { + let a = 0xABCDEF; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0xABCDEF + + let b = 0o755; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0o755 + + let c = 0b10101010; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0b10101010 + + let d = 0xABC_DEF; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0xABC_DEF + + let e = 0o7_55; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0o7_55 + + let f = 0b1010_1010; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0b1010_1010 + + let g = 0xABC_DEF_u64; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0xABC_DEF_u64 + + let h = 0o7_55_u32; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0o7_55_u32 + + let i = 0b1010_1010_u8; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0b1010_1010_u8 + // + let j = 0xABCDEFu64; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0xABCDEFu64 + + let k = 0o755u32; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0o755u32 + + let l = 0b10101010u8; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0b10101010u8 +} diff --git a/src/test/ui/numeric/uppercase-base-prefix.rs b/src/test/ui/numeric/uppercase-base-prefix.rs new file mode 100644 index 000000000..233d553da --- /dev/null +++ b/src/test/ui/numeric/uppercase-base-prefix.rs @@ -0,0 +1,77 @@ +// run-rustfix +// Checks that integers with an uppercase base prefix (0B, 0X, 0O) have a nice error +#![allow(unused_variables)] + +fn main() { + let a = 0XABCDEF; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0xABCDEF + + let b = 0O755; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0o755 + + let c = 0B10101010; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0b10101010 + + let d = 0XABC_DEF; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0xABC_DEF + + let e = 0O7_55; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0o7_55 + + let f = 0B1010_1010; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0b1010_1010 + + let g = 0XABC_DEF_u64; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0xABC_DEF_u64 + + let h = 0O7_55_u32; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0o7_55_u32 + + let i = 0B1010_1010_u8; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0b1010_1010_u8 + // + let j = 0XABCDEFu64; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0xABCDEFu64 + + let k = 0O755u32; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0o755u32 + + let l = 0B10101010u8; + //~^ ERROR invalid base prefix for number literal + //~| NOTE base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + //~| HELP try making the prefix lowercase + //~| SUGGESTION 0b10101010u8 +} diff --git a/src/test/ui/numeric/uppercase-base-prefix.stderr b/src/test/ui/numeric/uppercase-base-prefix.stderr new file mode 100644 index 000000000..4ba8d5224 --- /dev/null +++ b/src/test/ui/numeric/uppercase-base-prefix.stderr @@ -0,0 +1,98 @@ +error: invalid base prefix for number literal + --> $DIR/uppercase-base-prefix.rs:6:13 + | +LL | let a = 0XABCDEF; + | ^^^^^^^^ help: try making the prefix lowercase (notice the capitalization): `0xABCDEF` + | + = note: base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + +error: invalid base prefix for number literal + --> $DIR/uppercase-base-prefix.rs:12:13 + | +LL | let b = 0O755; + | ^^^^^ help: try making the prefix lowercase (notice the capitalization): `0o755` + | + = note: base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + +error: invalid base prefix for number literal + --> $DIR/uppercase-base-prefix.rs:18:13 + | +LL | let c = 0B10101010; + | ^^^^^^^^^^ help: try making the prefix lowercase: `0b10101010` + | + = note: base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + +error: invalid base prefix for number literal + --> $DIR/uppercase-base-prefix.rs:24:13 + | +LL | let d = 0XABC_DEF; + | ^^^^^^^^^ help: try making the prefix lowercase (notice the capitalization): `0xABC_DEF` + | + = note: base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + +error: invalid base prefix for number literal + --> $DIR/uppercase-base-prefix.rs:30:13 + | +LL | let e = 0O7_55; + | ^^^^^^ help: try making the prefix lowercase (notice the capitalization): `0o7_55` + | + = note: base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + +error: invalid base prefix for number literal + --> $DIR/uppercase-base-prefix.rs:36:13 + | +LL | let f = 0B1010_1010; + | ^^^^^^^^^^^ help: try making the prefix lowercase: `0b1010_1010` + | + = note: base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + +error: invalid base prefix for number literal + --> $DIR/uppercase-base-prefix.rs:42:13 + | +LL | let g = 0XABC_DEF_u64; + | ^^^^^^^^^^^^^ help: try making the prefix lowercase (notice the capitalization): `0xABC_DEF_u64` + | + = note: base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + +error: invalid base prefix for number literal + --> $DIR/uppercase-base-prefix.rs:48:13 + | +LL | let h = 0O7_55_u32; + | ^^^^^^^^^^ help: try making the prefix lowercase (notice the capitalization): `0o7_55_u32` + | + = note: base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + +error: invalid base prefix for number literal + --> $DIR/uppercase-base-prefix.rs:54:13 + | +LL | let i = 0B1010_1010_u8; + | ^^^^^^^^^^^^^^ help: try making the prefix lowercase: `0b1010_1010_u8` + | + = note: base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + +error: invalid base prefix for number literal + --> $DIR/uppercase-base-prefix.rs:60:13 + | +LL | let j = 0XABCDEFu64; + | ^^^^^^^^^^^ help: try making the prefix lowercase (notice the capitalization): `0xABCDEFu64` + | + = note: base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + +error: invalid base prefix for number literal + --> $DIR/uppercase-base-prefix.rs:66:13 + | +LL | let k = 0O755u32; + | ^^^^^^^^ help: try making the prefix lowercase (notice the capitalization): `0o755u32` + | + = note: base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + +error: invalid base prefix for number literal + --> $DIR/uppercase-base-prefix.rs:72:13 + | +LL | let l = 0B10101010u8; + | ^^^^^^^^^^^^ help: try making the prefix lowercase: `0b10101010u8` + | + = note: base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase + +error: aborting due to 12 previous errors + |