diff options
Diffstat (limited to 'src/test/ui/numeric')
44 files changed, 0 insertions, 11236 deletions
diff --git a/src/test/ui/numeric/const-scope.rs b/src/test/ui/numeric/const-scope.rs deleted file mode 100644 index 053599a9b..000000000 --- a/src/test/ui/numeric/const-scope.rs +++ /dev/null @@ -1,12 +0,0 @@ -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 deleted file mode 100644 index 4e4bcdf23..000000000 --- a/src/test/ui/numeric/const-scope.stderr +++ /dev/null @@ -1,67 +0,0 @@ -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 deleted file mode 100644 index c320f2bb7..000000000 --- a/src/test/ui/numeric/integer-literal-suffix-inference.rs +++ /dev/null @@ -1,220 +0,0 @@ -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 deleted file mode 100644 index 5045f584c..000000000 --- a/src/test/ui/numeric/integer-literal-suffix-inference.stderr +++ /dev/null @@ -1,939 +0,0 @@ -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 deleted file mode 100644 index a72540988..000000000 --- a/src/test/ui/numeric/len.rs +++ /dev/null @@ -1,8 +0,0 @@ -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 deleted file mode 100644 index 55a61b5e4..000000000 --- a/src/test/ui/numeric/len.stderr +++ /dev/null @@ -1,21 +0,0 @@ -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 deleted file mode 100644 index ad2de5d2b..000000000 --- a/src/test/ui/numeric/numeric-cast-2.rs +++ /dev/null @@ -1,11 +0,0 @@ -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 deleted file mode 100644 index a7b342739..000000000 --- a/src/test/ui/numeric/numeric-cast-2.stderr +++ /dev/null @@ -1,42 +0,0 @@ -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 deleted file mode 100644 index edb085e71..000000000 --- a/src/test/ui/numeric/numeric-cast-binop.fixed +++ /dev/null @@ -1,320 +0,0 @@ -// 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 deleted file mode 100644 index c1ed8de8a..000000000 --- a/src/test/ui/numeric/numeric-cast-binop.rs +++ /dev/null @@ -1,320 +0,0 @@ -// 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 deleted file mode 100644 index 2f58f1649..000000000 --- a/src/test/ui/numeric/numeric-cast-binop.stderr +++ /dev/null @@ -1,1455 +0,0 @@ -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 deleted file mode 100644 index 63e5f098a..000000000 --- a/src/test/ui/numeric/numeric-cast-no-fix.rs +++ /dev/null @@ -1,87 +0,0 @@ -#[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 deleted file mode 100644 index e4843206d..000000000 --- a/src/test/ui/numeric/numeric-cast-no-fix.stderr +++ /dev/null @@ -1,324 +0,0 @@ -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 deleted file mode 100644 index faf24a8c1..000000000 --- a/src/test/ui/numeric/numeric-cast-without-suggestion.rs +++ /dev/null @@ -1,38 +0,0 @@ -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 deleted file mode 100644 index 581b548ab..000000000 --- a/src/test/ui/numeric/numeric-cast-without-suggestion.stderr +++ /dev/null @@ -1,297 +0,0 @@ -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 deleted file mode 100644 index cf0560a10..000000000 --- a/src/test/ui/numeric/numeric-cast.fixed +++ /dev/null @@ -1,293 +0,0 @@ -// 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 deleted file mode 100644 index 7bddfc509..000000000 --- a/src/test/ui/numeric/numeric-cast.rs +++ /dev/null @@ -1,293 +0,0 @@ -// 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 deleted file mode 100644 index d347875d5..000000000 --- a/src/test/ui/numeric/numeric-cast.stderr +++ /dev/null @@ -1,2037 +0,0 @@ -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 deleted file mode 100644 index 28234bbdf..000000000 --- a/src/test/ui/numeric/numeric-fields.rs +++ /dev/null @@ -1,10 +0,0 @@ -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 deleted file mode 100644 index 668405ed6..000000000 --- a/src/test/ui/numeric/numeric-fields.stderr +++ /dev/null @@ -1,27 +0,0 @@ -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 deleted file mode 100644 index 6e8c54df4..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.fixed +++ /dev/null @@ -1,73 +0,0 @@ -// 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 deleted file mode 100644 index b47b0ed02..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.rs +++ /dev/null @@ -1,73 +0,0 @@ -// 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 deleted file mode 100644 index f4fb14e79..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i32.stderr +++ /dev/null @@ -1,201 +0,0 @@ -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 deleted file mode 100644 index 03821cd44..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.fixed +++ /dev/null @@ -1,73 +0,0 @@ -// 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 deleted file mode 100644 index 629fe7e74..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.rs +++ /dev/null @@ -1,73 +0,0 @@ -// 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 deleted file mode 100644 index 47efe9f08..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-i64.stderr +++ /dev/null @@ -1,201 +0,0 @@ -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 deleted file mode 100644 index faed65ca4..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.fixed +++ /dev/null @@ -1,73 +0,0 @@ -// 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 deleted file mode 100644 index df0b4cb62..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.rs +++ /dev/null @@ -1,73 +0,0 @@ -// 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 deleted file mode 100644 index 28b79413f..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-isize.stderr +++ /dev/null @@ -1,201 +0,0 @@ -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 deleted file mode 100644 index 5955829e7..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.fixed +++ /dev/null @@ -1,73 +0,0 @@ -// 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 deleted file mode 100644 index 5c303036a..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.rs +++ /dev/null @@ -1,73 +0,0 @@ -// 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 deleted file mode 100644 index d966893a8..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u32.stderr +++ /dev/null @@ -1,201 +0,0 @@ -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 deleted file mode 100644 index 4623c211c..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.fixed +++ /dev/null @@ -1,73 +0,0 @@ -// 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 deleted file mode 100644 index 3e9995c74..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.rs +++ /dev/null @@ -1,73 +0,0 @@ -// 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 deleted file mode 100644 index ff332fa91..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-u64.stderr +++ /dev/null @@ -1,201 +0,0 @@ -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 deleted file mode 100644 index 6cb5243ca..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.fixed +++ /dev/null @@ -1,73 +0,0 @@ -// 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 deleted file mode 100644 index a2304ba26..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.rs +++ /dev/null @@ -1,73 +0,0 @@ -// 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 deleted file mode 100644 index 4889abee6..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix-usize.stderr +++ /dev/null @@ -1,201 +0,0 @@ -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 deleted file mode 100644 index 69934db21..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix.fixed +++ /dev/null @@ -1,427 +0,0 @@ -// 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 deleted file mode 100644 index dabf43f82..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix.rs +++ /dev/null @@ -1,427 +0,0 @@ -// 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 deleted file mode 100644 index e05913b9c..000000000 --- a/src/test/ui/numeric/numeric-suffix/numeric-suffix.stderr +++ /dev/null @@ -1,1227 +0,0 @@ -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 deleted file mode 100644 index 1b1c837ec..000000000 --- a/src/test/ui/numeric/uppercase-base-prefix.fixed +++ /dev/null @@ -1,77 +0,0 @@ -// 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 deleted file mode 100644 index 233d553da..000000000 --- a/src/test/ui/numeric/uppercase-base-prefix.rs +++ /dev/null @@ -1,77 +0,0 @@ -// 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 deleted file mode 100644 index 4ba8d5224..000000000 --- a/src/test/ui/numeric/uppercase-base-prefix.stderr +++ /dev/null @@ -1,98 +0,0 @@ -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 - |