error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:7:18
   |
LL |     foo::<usize>(42_u64);
   |                  ^^^^^^ expected `usize`, found `u64`
   |
help: change the type of the numeric literal from `u64` to `usize`
   |
LL |     foo::<usize>(42_usize);
   |                  ^^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:9:18
   |
LL |     foo::<usize>(42_u32);
   |                  ^^^^^^ expected `usize`, found `u32`
   |
help: change the type of the numeric literal from `u32` to `usize`
   |
LL |     foo::<usize>(42_usize);
   |                  ^^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:11:18
   |
LL |     foo::<usize>(42_u16);
   |                  ^^^^^^ expected `usize`, found `u16`
   |
help: change the type of the numeric literal from `u16` to `usize`
   |
LL |     foo::<usize>(42_usize);
   |                  ^^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:13:18
   |
LL |     foo::<usize>(42_u8);
   |                  ^^^^^ expected `usize`, found `u8`
   |
help: change the type of the numeric literal from `u8` to `usize`
   |
LL |     foo::<usize>(42_usize);
   |                  ^^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:15:18
   |
LL |     foo::<usize>(42_isize);
   |                  ^^^^^^^^ expected `usize`, found `isize`
   |
help: change the type of the numeric literal from `isize` to `usize`
   |
LL |     foo::<usize>(42_usize);
   |                  ^^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:17:18
   |
LL |     foo::<usize>(42_i64);
   |                  ^^^^^^ expected `usize`, found `i64`
   |
help: change the type of the numeric literal from `i64` to `usize`
   |
LL |     foo::<usize>(42_usize);
   |                  ^^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:19:18
   |
LL |     foo::<usize>(42_i32);
   |                  ^^^^^^ expected `usize`, found `i32`
   |
help: change the type of the numeric literal from `i32` to `usize`
   |
LL |     foo::<usize>(42_usize);
   |                  ^^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:21:18
   |
LL |     foo::<usize>(42_i16);
   |                  ^^^^^^ expected `usize`, found `i16`
   |
help: change the type of the numeric literal from `i16` to `usize`
   |
LL |     foo::<usize>(42_usize);
   |                  ^^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:23:18
   |
LL |     foo::<usize>(42_i8);
   |                  ^^^^^ expected `usize`, found `i8`
   |
help: change the type of the numeric literal from `i8` to `usize`
   |
LL |     foo::<usize>(42_usize);
   |                  ^^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:25:18
   |
LL |     foo::<usize>(42.0_f64);
   |                  ^^^^^^^^ expected `usize`, found `f64`
   |
help: change the type of the numeric literal from `f64` to `usize`
   |
LL |     foo::<usize>(42usize);
   |                  ^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:27:18
   |
LL |     foo::<usize>(42.0_f32);
   |                  ^^^^^^^^ expected `usize`, found `f32`
   |
help: change the type of the numeric literal from `f32` to `usize`
   |
LL |     foo::<usize>(42usize);
   |                  ^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:30:18
   |
LL |     foo::<isize>(42_usize);
   |                  ^^^^^^^^ expected `isize`, found `usize`
   |
help: change the type of the numeric literal from `usize` to `isize`
   |
LL |     foo::<isize>(42_isize);
   |                  ^^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:32:18
   |
LL |     foo::<isize>(42_u64);
   |                  ^^^^^^ expected `isize`, found `u64`
   |
help: change the type of the numeric literal from `u64` to `isize`
   |
LL |     foo::<isize>(42_isize);
   |                  ^^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:34:18
   |
LL |     foo::<isize>(42_u32);
   |                  ^^^^^^ expected `isize`, found `u32`
   |
help: change the type of the numeric literal from `u32` to `isize`
   |
LL |     foo::<isize>(42_isize);
   |                  ^^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:36:18
   |
LL |     foo::<isize>(42_u16);
   |                  ^^^^^^ expected `isize`, found `u16`
   |
help: change the type of the numeric literal from `u16` to `isize`
   |
LL |     foo::<isize>(42_isize);
   |                  ^^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:38:18
   |
LL |     foo::<isize>(42_u8);
   |                  ^^^^^ expected `isize`, found `u8`
   |
help: change the type of the numeric literal from `u8` to `isize`
   |
LL |     foo::<isize>(42_isize);
   |                  ^^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:41:18
   |
LL |     foo::<isize>(42_i64);
   |                  ^^^^^^ expected `isize`, found `i64`
   |
help: change the type of the numeric literal from `i64` to `isize`
   |
LL |     foo::<isize>(42_isize);
   |                  ^^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:43:18
   |
LL |     foo::<isize>(42_i32);
   |                  ^^^^^^ expected `isize`, found `i32`
   |
help: change the type of the numeric literal from `i32` to `isize`
   |
LL |     foo::<isize>(42_isize);
   |                  ^^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:45:18
   |
LL |     foo::<isize>(42_i16);
   |                  ^^^^^^ expected `isize`, found `i16`
   |
help: change the type of the numeric literal from `i16` to `isize`
   |
LL |     foo::<isize>(42_isize);
   |                  ^^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:47:18
   |
LL |     foo::<isize>(42_i8);
   |                  ^^^^^ expected `isize`, found `i8`
   |
help: change the type of the numeric literal from `i8` to `isize`
   |
LL |     foo::<isize>(42_isize);
   |                  ^^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:49:18
   |
LL |     foo::<isize>(42.0_f64);
   |                  ^^^^^^^^ expected `isize`, found `f64`
   |
help: change the type of the numeric literal from `f64` to `isize`
   |
LL |     foo::<isize>(42isize);
   |                  ^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:51:18
   |
LL |     foo::<isize>(42.0_f32);
   |                  ^^^^^^^^ expected `isize`, found `f32`
   |
help: change the type of the numeric literal from `f32` to `isize`
   |
LL |     foo::<isize>(42isize);
   |                  ^^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:54:16
   |
LL |     foo::<u64>(42_usize);
   |                ^^^^^^^^ expected `u64`, found `usize`
   |
help: change the type of the numeric literal from `usize` to `u64`
   |
LL |     foo::<u64>(42_u64);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:57:16
   |
LL |     foo::<u64>(42_u32);
   |                ^^^^^^ expected `u64`, found `u32`
   |
help: change the type of the numeric literal from `u32` to `u64`
   |
LL |     foo::<u64>(42_u64);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:59:16
   |
LL |     foo::<u64>(42_u16);
   |                ^^^^^^ expected `u64`, found `u16`
   |
help: change the type of the numeric literal from `u16` to `u64`
   |
LL |     foo::<u64>(42_u64);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:61:16
   |
LL |     foo::<u64>(42_u8);
   |                ^^^^^ expected `u64`, found `u8`
   |
help: change the type of the numeric literal from `u8` to `u64`
   |
LL |     foo::<u64>(42_u64);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:63:16
   |
LL |     foo::<u64>(42_isize);
   |                ^^^^^^^^ expected `u64`, found `isize`
   |
help: change the type of the numeric literal from `isize` to `u64`
   |
LL |     foo::<u64>(42_u64);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:65:16
   |
LL |     foo::<u64>(42_i64);
   |                ^^^^^^ expected `u64`, found `i64`
   |
help: change the type of the numeric literal from `i64` to `u64`
   |
LL |     foo::<u64>(42_u64);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:67:16
   |
LL |     foo::<u64>(42_i32);
   |                ^^^^^^ expected `u64`, found `i32`
   |
help: change the type of the numeric literal from `i32` to `u64`
   |
LL |     foo::<u64>(42_u64);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:69:16
   |
LL |     foo::<u64>(42_i16);
   |                ^^^^^^ expected `u64`, found `i16`
   |
help: change the type of the numeric literal from `i16` to `u64`
   |
LL |     foo::<u64>(42_u64);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:71:16
   |
LL |     foo::<u64>(42_i8);
   |                ^^^^^ expected `u64`, found `i8`
   |
help: change the type of the numeric literal from `i8` to `u64`
   |
LL |     foo::<u64>(42_u64);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:73:16
   |
LL |     foo::<u64>(42.0_f64);
   |                ^^^^^^^^ expected `u64`, found `f64`
   |
help: change the type of the numeric literal from `f64` to `u64`
   |
LL |     foo::<u64>(42u64);
   |                ^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:75:16
   |
LL |     foo::<u64>(42.0_f32);
   |                ^^^^^^^^ expected `u64`, found `f32`
   |
help: change the type of the numeric literal from `f32` to `u64`
   |
LL |     foo::<u64>(42u64);
   |                ^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:78:16
   |
LL |     foo::<i64>(42_usize);
   |                ^^^^^^^^ expected `i64`, found `usize`
   |
help: change the type of the numeric literal from `usize` to `i64`
   |
LL |     foo::<i64>(42_i64);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:80:16
   |
LL |     foo::<i64>(42_u64);
   |                ^^^^^^ expected `i64`, found `u64`
   |
help: change the type of the numeric literal from `u64` to `i64`
   |
LL |     foo::<i64>(42_i64);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:82:16
   |
LL |     foo::<i64>(42_u32);
   |                ^^^^^^ expected `i64`, found `u32`
   |
help: change the type of the numeric literal from `u32` to `i64`
   |
LL |     foo::<i64>(42_i64);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:84:16
   |
LL |     foo::<i64>(42_u16);
   |                ^^^^^^ expected `i64`, found `u16`
   |
help: change the type of the numeric literal from `u16` to `i64`
   |
LL |     foo::<i64>(42_i64);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:86:16
   |
LL |     foo::<i64>(42_u8);
   |                ^^^^^ expected `i64`, found `u8`
   |
help: change the type of the numeric literal from `u8` to `i64`
   |
LL |     foo::<i64>(42_i64);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:88:16
   |
LL |     foo::<i64>(42_isize);
   |                ^^^^^^^^ expected `i64`, found `isize`
   |
help: change the type of the numeric literal from `isize` to `i64`
   |
LL |     foo::<i64>(42_i64);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:91:16
   |
LL |     foo::<i64>(42_i32);
   |                ^^^^^^ expected `i64`, found `i32`
   |
help: change the type of the numeric literal from `i32` to `i64`
   |
LL |     foo::<i64>(42_i64);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:93:16
   |
LL |     foo::<i64>(42_i16);
   |                ^^^^^^ expected `i64`, found `i16`
   |
help: change the type of the numeric literal from `i16` to `i64`
   |
LL |     foo::<i64>(42_i64);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:95:16
   |
LL |     foo::<i64>(42_i8);
   |                ^^^^^ expected `i64`, found `i8`
   |
help: change the type of the numeric literal from `i8` to `i64`
   |
LL |     foo::<i64>(42_i64);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:97:16
   |
LL |     foo::<i64>(42.0_f64);
   |                ^^^^^^^^ expected `i64`, found `f64`
   |
help: change the type of the numeric literal from `f64` to `i64`
   |
LL |     foo::<i64>(42i64);
   |                ^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:99:16
   |
LL |     foo::<i64>(42.0_f32);
   |                ^^^^^^^^ expected `i64`, found `f32`
   |
help: change the type of the numeric literal from `f32` to `i64`
   |
LL |     foo::<i64>(42i64);
   |                ^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:102:16
   |
LL |     foo::<u32>(42_usize);
   |                ^^^^^^^^ expected `u32`, found `usize`
   |
help: change the type of the numeric literal from `usize` to `u32`
   |
LL |     foo::<u32>(42_u32);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:104:16
   |
LL |     foo::<u32>(42_u64);
   |                ^^^^^^ expected `u32`, found `u64`
   |
help: change the type of the numeric literal from `u64` to `u32`
   |
LL |     foo::<u32>(42_u32);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:107:16
   |
LL |     foo::<u32>(42_u16);
   |                ^^^^^^ expected `u32`, found `u16`
   |
help: change the type of the numeric literal from `u16` to `u32`
   |
LL |     foo::<u32>(42_u32);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:109:16
   |
LL |     foo::<u32>(42_u8);
   |                ^^^^^ expected `u32`, found `u8`
   |
help: change the type of the numeric literal from `u8` to `u32`
   |
LL |     foo::<u32>(42_u32);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:111:16
   |
LL |     foo::<u32>(42_isize);
   |                ^^^^^^^^ expected `u32`, found `isize`
   |
help: change the type of the numeric literal from `isize` to `u32`
   |
LL |     foo::<u32>(42_u32);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:113:16
   |
LL |     foo::<u32>(42_i64);
   |                ^^^^^^ expected `u32`, found `i64`
   |
help: change the type of the numeric literal from `i64` to `u32`
   |
LL |     foo::<u32>(42_u32);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:115:16
   |
LL |     foo::<u32>(42_i32);
   |                ^^^^^^ expected `u32`, found `i32`
   |
help: change the type of the numeric literal from `i32` to `u32`
   |
LL |     foo::<u32>(42_u32);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:117:16
   |
LL |     foo::<u32>(42_i16);
   |                ^^^^^^ expected `u32`, found `i16`
   |
help: change the type of the numeric literal from `i16` to `u32`
   |
LL |     foo::<u32>(42_u32);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:119:16
   |
LL |     foo::<u32>(42_i8);
   |                ^^^^^ expected `u32`, found `i8`
   |
help: change the type of the numeric literal from `i8` to `u32`
   |
LL |     foo::<u32>(42_u32);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:121:16
   |
LL |     foo::<u32>(42.0_f64);
   |                ^^^^^^^^ expected `u32`, found `f64`
   |
help: change the type of the numeric literal from `f64` to `u32`
   |
LL |     foo::<u32>(42u32);
   |                ^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:123:16
   |
LL |     foo::<u32>(42.0_f32);
   |                ^^^^^^^^ expected `u32`, found `f32`
   |
help: change the type of the numeric literal from `f32` to `u32`
   |
LL |     foo::<u32>(42u32);
   |                ^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:126:16
   |
LL |     foo::<i32>(42_usize);
   |                ^^^^^^^^ expected `i32`, found `usize`
   |
help: change the type of the numeric literal from `usize` to `i32`
   |
LL |     foo::<i32>(42_i32);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:128:16
   |
LL |     foo::<i32>(42_u64);
   |                ^^^^^^ expected `i32`, found `u64`
   |
help: change the type of the numeric literal from `u64` to `i32`
   |
LL |     foo::<i32>(42_i32);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:130:16
   |
LL |     foo::<i32>(42_u32);
   |                ^^^^^^ expected `i32`, found `u32`
   |
help: change the type of the numeric literal from `u32` to `i32`
   |
LL |     foo::<i32>(42_i32);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:132:16
   |
LL |     foo::<i32>(42_u16);
   |                ^^^^^^ expected `i32`, found `u16`
   |
help: change the type of the numeric literal from `u16` to `i32`
   |
LL |     foo::<i32>(42_i32);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:134:16
   |
LL |     foo::<i32>(42_u8);
   |                ^^^^^ expected `i32`, found `u8`
   |
help: change the type of the numeric literal from `u8` to `i32`
   |
LL |     foo::<i32>(42_i32);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:136:16
   |
LL |     foo::<i32>(42_isize);
   |                ^^^^^^^^ expected `i32`, found `isize`
   |
help: change the type of the numeric literal from `isize` to `i32`
   |
LL |     foo::<i32>(42_i32);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:138:16
   |
LL |     foo::<i32>(42_i64);
   |                ^^^^^^ expected `i32`, found `i64`
   |
help: change the type of the numeric literal from `i64` to `i32`
   |
LL |     foo::<i32>(42_i32);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:141:16
   |
LL |     foo::<i32>(42_i16);
   |                ^^^^^^ expected `i32`, found `i16`
   |
help: change the type of the numeric literal from `i16` to `i32`
   |
LL |     foo::<i32>(42_i32);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:143:16
   |
LL |     foo::<i32>(42_i8);
   |                ^^^^^ expected `i32`, found `i8`
   |
help: change the type of the numeric literal from `i8` to `i32`
   |
LL |     foo::<i32>(42_i32);
   |                ^^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:145:16
   |
LL |     foo::<i32>(42.0_f64);
   |                ^^^^^^^^ expected `i32`, found `f64`
   |
help: change the type of the numeric literal from `f64` to `i32`
   |
LL |     foo::<i32>(42i32);
   |                ^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:147:16
   |
LL |     foo::<i32>(42.0_f32);
   |                ^^^^^^^^ expected `i32`, found `f32`
   |
help: change the type of the numeric literal from `f32` to `i32`
   |
LL |     foo::<i32>(42i32);
   |                ^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:150:16
   |
LL |     foo::<u16>(42_usize);
   |                ^^^^^^^^ expected `u16`, found `usize`
   |
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:152:16
   |
LL |     foo::<u16>(42_u64);
   |                ^^^^^^ expected `u16`, found `u64`
   |
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:154:16
   |
LL |     foo::<u16>(42_u32);
   |                ^^^^^^ expected `u16`, found `u32`
   |
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:157:16
   |
LL |     foo::<u16>(42_u8);
   |                ^^^^^ expected `u16`, found `u8`
   |
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:159:16
   |
LL |     foo::<u16>(42_isize);
   |                ^^^^^^^^ expected `u16`, found `isize`
   |
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:161:16
   |
LL |     foo::<u16>(42_i64);
   |                ^^^^^^ expected `u16`, found `i64`
   |
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:163:16
   |
LL |     foo::<u16>(42_i32);
   |                ^^^^^^ expected `u16`, found `i32`
   |
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:165:16
   |
LL |     foo::<u16>(42_i16);
   |                ^^^^^^ expected `u16`, found `i16`
   |
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:167:16
   |
LL |     foo::<u16>(42_i8);
   |                ^^^^^ expected `u16`, found `i8`
   |
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:169:16
   |
LL |     foo::<u16>(42.0_f64);
   |                ^^^^^^^^ expected `u16`, found `f64`
   |
help: change the type of the numeric literal from `f64` to `u16`
   |
LL |     foo::<u16>(42u16);
   |                ^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:171:16
   |
LL |     foo::<u16>(42.0_f32);
   |                ^^^^^^^^ expected `u16`, found `f32`
   |
help: change the type of the numeric literal from `f32` to `u16`
   |
LL |     foo::<u16>(42u16);
   |                ^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:174:16
   |
LL |     foo::<i16>(42_usize);
   |                ^^^^^^^^ expected `i16`, found `usize`
   |
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:176:16
   |
LL |     foo::<i16>(42_u64);
   |                ^^^^^^ expected `i16`, found `u64`
   |
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:178:16
   |
LL |     foo::<i16>(42_u32);
   |                ^^^^^^ expected `i16`, found `u32`
   |
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:180:16
   |
LL |     foo::<i16>(42_u16);
   |                ^^^^^^ expected `i16`, found `u16`
   |
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:182:16
   |
LL |     foo::<i16>(42_u8);
   |                ^^^^^ expected `i16`, found `u8`
   |
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:184:16
   |
LL |     foo::<i16>(42_isize);
   |                ^^^^^^^^ expected `i16`, found `isize`
   |
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:186:16
   |
LL |     foo::<i16>(42_i64);
   |                ^^^^^^ expected `i16`, found `i64`
   |
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:188:16
   |
LL |     foo::<i16>(42_i32);
   |                ^^^^^^ expected `i16`, found `i32`
   |
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:191:16
   |
LL |     foo::<i16>(42_i8);
   |                ^^^^^ expected `i16`, found `i8`
   |
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:193:16
   |
LL |     foo::<i16>(42.0_f64);
   |                ^^^^^^^^ expected `i16`, found `f64`
   |
help: change the type of the numeric literal from `f64` to `i16`
   |
LL |     foo::<i16>(42i16);
   |                ^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:195:16
   |
LL |     foo::<i16>(42.0_f32);
   |                ^^^^^^^^ expected `i16`, found `f32`
   |
help: change the type of the numeric literal from `f32` to `i16`
   |
LL |     foo::<i16>(42i16);
   |                ^^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:198:15
   |
LL |     foo::<u8>(42_usize);
   |               ^^^^^^^^ expected `u8`, found `usize`
   |
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:200:15
   |
LL |     foo::<u8>(42_u64);
   |               ^^^^^^ expected `u8`, found `u64`
   |
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:202:15
   |
LL |     foo::<u8>(42_u32);
   |               ^^^^^^ expected `u8`, found `u32`
   |
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:204:15
   |
LL |     foo::<u8>(42_u16);
   |               ^^^^^^ expected `u8`, found `u16`
   |
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:207:15
   |
LL |     foo::<u8>(42_isize);
   |               ^^^^^^^^ expected `u8`, found `isize`
   |
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:209:15
   |
LL |     foo::<u8>(42_i64);
   |               ^^^^^^ expected `u8`, found `i64`
   |
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:211:15
   |
LL |     foo::<u8>(42_i32);
   |               ^^^^^^ expected `u8`, found `i32`
   |
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:213:15
   |
LL |     foo::<u8>(42_i16);
   |               ^^^^^^ expected `u8`, found `i16`
   |
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:215:15
   |
LL |     foo::<u8>(42_i8);
   |               ^^^^^ expected `u8`, found `i8`
   |
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:217:15
   |
LL |     foo::<u8>(42.0_f64);
   |               ^^^^^^^^ expected `u8`, found `f64`
   |
help: change the type of the numeric literal from `f64` to `u8`
   |
LL |     foo::<u8>(42u8);
   |               ^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:219:15
   |
LL |     foo::<u8>(42.0_f32);
   |               ^^^^^^^^ expected `u8`, found `f32`
   |
help: change the type of the numeric literal from `f32` to `u8`
   |
LL |     foo::<u8>(42u8);
   |               ^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:222:15
   |
LL |     foo::<i8>(42_usize);
   |               ^^^^^^^^ expected `i8`, found `usize`
   |
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:224:15
   |
LL |     foo::<i8>(42_u64);
   |               ^^^^^^ expected `i8`, found `u64`
   |
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:226:15
   |
LL |     foo::<i8>(42_u32);
   |               ^^^^^^ expected `i8`, found `u32`
   |
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:228:15
   |
LL |     foo::<i8>(42_u16);
   |               ^^^^^^ expected `i8`, found `u16`
   |
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:230:15
   |
LL |     foo::<i8>(42_u8);
   |               ^^^^^ expected `i8`, found `u8`
   |
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:232:15
   |
LL |     foo::<i8>(42_isize);
   |               ^^^^^^^^ expected `i8`, found `isize`
   |
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:234:15
   |
LL |     foo::<i8>(42_i64);
   |               ^^^^^^ expected `i8`, found `i64`
   |
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:236:15
   |
LL |     foo::<i8>(42_i32);
   |               ^^^^^^ expected `i8`, found `i32`
   |
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:238:15
   |
LL |     foo::<i8>(42_i16);
   |               ^^^^^^ expected `i8`, found `i16`
   |
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:241:15
   |
LL |     foo::<i8>(42.0_f64);
   |               ^^^^^^^^ expected `i8`, found `f64`
   |
help: change the type of the numeric literal from `f64` to `i8`
   |
LL |     foo::<i8>(42i8);
   |               ^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:243:15
   |
LL |     foo::<i8>(42.0_f32);
   |               ^^^^^^^^ expected `i8`, found `f32`
   |
help: change the type of the numeric literal from `f32` to `i8`
   |
LL |     foo::<i8>(42i8);
   |               ^^^^

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:246:16
   |
LL |     foo::<f64>(42_usize);
   |                ^^^^^^^^ expected `f64`, found `usize`
   |
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:248:16
   |
LL |     foo::<f64>(42_u64);
   |                ^^^^^^ expected `f64`, found `u64`
   |
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:250:16
   |
LL |     foo::<f64>(42_u32);
   |                ^^^^^^ expected `f64`, found `u32`
   |
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:252:16
   |
LL |     foo::<f64>(42_u16);
   |                ^^^^^^ expected `f64`, found `u16`
   |
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:254:16
   |
LL |     foo::<f64>(42_u8);
   |                ^^^^^ expected `f64`, found `u8`
   |
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:256:16
   |
LL |     foo::<f64>(42_isize);
   |                ^^^^^^^^ expected `f64`, found `isize`
   |
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:258:16
   |
LL |     foo::<f64>(42_i64);
   |                ^^^^^^ expected `f64`, found `i64`
   |
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:260:16
   |
LL |     foo::<f64>(42_i32);
   |                ^^^^^^ expected `f64`, found `i32`
   |
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:262:16
   |
LL |     foo::<f64>(42_i16);
   |                ^^^^^^ expected `f64`, found `i16`
   |
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:264:16
   |
LL |     foo::<f64>(42_i8);
   |                ^^^^^ expected `f64`, found `i8`
   |
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:267:16
   |
LL |     foo::<f64>(42.0_f32);
   |                ^^^^^^^^ expected `f64`, found `f32`
   |
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:270:16
   |
LL |     foo::<f32>(42_usize);
   |                ^^^^^^^^ expected `f32`, found `usize`
   |
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:272:16
   |
LL |     foo::<f32>(42_u64);
   |                ^^^^^^ expected `f32`, found `u64`
   |
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:274:16
   |
LL |     foo::<f32>(42_u32);
   |                ^^^^^^ expected `f32`, found `u32`
   |
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:276:16
   |
LL |     foo::<f32>(42_u16);
   |                ^^^^^^ expected `f32`, found `u16`
   |
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:278:16
   |
LL |     foo::<f32>(42_u8);
   |                ^^^^^ expected `f32`, found `u8`
   |
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:280:16
   |
LL |     foo::<f32>(42_isize);
   |                ^^^^^^^^ expected `f32`, found `isize`
   |
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:282:16
   |
LL |     foo::<f32>(42_i64);
   |                ^^^^^^ expected `f32`, found `i64`
   |
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:284:16
   |
LL |     foo::<f32>(42_i32);
   |                ^^^^^^ expected `f32`, found `i32`
   |
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:286:16
   |
LL |     foo::<f32>(42_i16);
   |                ^^^^^^ expected `f32`, found `i16`
   |
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:288:16
   |
LL |     foo::<f32>(42_i8);
   |                ^^^^^ expected `f32`, found `i8`
   |
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:290:16
   |
LL |     foo::<f32>(42.0_f64);
   |                ^^^^^^^^ expected `f32`, found `f64`
   |
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:294:16
   |
LL |     foo::<u32>(42_u8 as u16);
   |                ^^^^^^^^^^^^
   |                |
   |                expected `u32`, found `u16`
   |                help: you can convert a `u16` to a `u32`: `(42_u8 as u16).into()`

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:296:16
   |
LL |     foo::<i32>(-42_i8);
   |                ^^^^^^
   |                |
   |                expected `i32`, found `i8`
   |                help: you can convert an `i8` to an `i32`: `(-42_i8).into()`

error: aborting due to 134 previous errors

For more information about this error, try `rustc --explain E0308`.