error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:74: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_usize);
LL +     foo::<u16>(42_u16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:78: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_u64);
LL +     foo::<u16>(42_u16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:82: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_u32);
LL +     foo::<u16>(42_u16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:87: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_u8);
LL +     foo::<u16>(42_u16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:91: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_isize);
LL +     foo::<u16>(42_u16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:95: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_i64);
LL +     foo::<u16>(42_u16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:99: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_i32);
LL +     foo::<u16>(42_u16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:103: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_i16);
LL +     foo::<u16>(42_u16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:107: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_i8);
LL +     foo::<u16>(42_u16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:111: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>(42.0_f64);
LL +     foo::<u16>(42u16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:115: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>(42.0_f32);
LL +     foo::<u16>(42u16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:120: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_usize);
LL +     foo::<i16>(42_i16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:124: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_u64);
LL +     foo::<i16>(42_i16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:128: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_u32);
LL +     foo::<i16>(42_i16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:132: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_u16);
LL +     foo::<i16>(42_i16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:136: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_u8);
LL +     foo::<i16>(42_i16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:140: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_isize);
LL +     foo::<i16>(42_i16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:144: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_i64);
LL +     foo::<i16>(42_i16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:148: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_i32);
LL +     foo::<i16>(42_i16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:153: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_i8);
LL +     foo::<i16>(42_i16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:157: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>(42.0_f64);
LL +     foo::<i16>(42i16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:161: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>(42.0_f32);
LL +     foo::<i16>(42i16);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:166: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_usize);
LL +     foo::<u8>(42_u8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:170: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_u64);
LL +     foo::<u8>(42_u8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:174: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_u32);
LL +     foo::<u8>(42_u8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:178: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_u16);
LL +     foo::<u8>(42_u8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:183: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_isize);
LL +     foo::<u8>(42_u8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:187: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_i64);
LL +     foo::<u8>(42_u8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:191: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_i32);
LL +     foo::<u8>(42_u8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:195: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_i16);
LL +     foo::<u8>(42_u8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:199: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_i8);
LL +     foo::<u8>(42_u8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:203: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>(42.0_f64);
LL +     foo::<u8>(42u8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:207: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>(42.0_f32);
LL +     foo::<u8>(42u8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:212: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_usize);
LL +     foo::<i8>(42_i8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:216: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_u64);
LL +     foo::<i8>(42_i8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:220: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_u32);
LL +     foo::<i8>(42_i8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:224: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_u16);
LL +     foo::<i8>(42_i8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:228: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_u8);
LL +     foo::<i8>(42_i8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:232: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_isize);
LL +     foo::<i8>(42_i8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:236: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_i64);
LL +     foo::<i8>(42_i8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:240: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_i32);
LL +     foo::<i8>(42_i8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:244: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_i16);
LL +     foo::<i8>(42_i8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:249: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>(42.0_f64);
LL +     foo::<i8>(42i8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:253: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>(42.0_f32);
LL +     foo::<i8>(42i8);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:258: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_usize);
LL +     foo::<f64>(42_f64);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:262: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_u64);
LL +     foo::<f64>(42_f64);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:266: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:270: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:274: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:278: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_isize);
LL +     foo::<f64>(42_f64);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:282: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_i64);
LL +     foo::<f64>(42_f64);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:286: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:290: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:294: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:299: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_f32);
LL +     foo::<f64>(42.0_f64);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:304: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_usize);
LL +     foo::<f32>(42_f32);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:308: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_u64);
LL +     foo::<f32>(42_f32);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:312: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_u32);
LL +     foo::<f32>(42_f32);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:316: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:320: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:324: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_isize);
LL +     foo::<f32>(42_f32);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:328: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_i64);
LL +     foo::<f32>(42_f32);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:332: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_i32);
LL +     foo::<f32>(42_f32);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:336: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:340: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:344: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_f64);
LL +     foo::<f32>(42.0_f32);
   |

error[E0308]: mismatched types
  --> $DIR/numeric-suffix.rs:350: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:354: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`.