diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 6f122daf71a..4ea34182294 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -10,7 +10,7 @@ use rustc::hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisito
 use rustc::hir::*;
 use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass};
 use rustc::ty::layout::LayoutOf;
-use rustc::ty::{self, Ty, TyCtxt, TypeckTables};
+use rustc::ty::{self, InferTy, Ty, TyCtxt, TypeckTables};
 use rustc::{declare_tool_lint, lint_array};
 use rustc_errors::Applicability;
 use rustc_target::spec::abi::Abi;
@@ -1150,6 +1150,16 @@ fn is_c_void(tcx: TyCtxt<'_, '_, '_>, ty: Ty<'_>) -> bool {
     false
 }
 
+/// Returns the mantissa bits wide of a fp type.
+/// Will return 0 if the type is not a fp
+fn fp_ty_mantissa_nbits(typ: Ty<'_>) -> u32 {
+    match typ.sty {
+        ty::Float(FloatTy::F32) => 23,
+        ty::Float(FloatTy::F64) | ty::Infer(InferTy::FloatVar(_)) => 52,
+        _ => 0,
+    }
+}
+
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CastPass {
     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
         if let ExprKind::Cast(ref ex, _) = expr.node {
@@ -1157,6 +1167,24 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CastPass {
             lint_fn_to_numeric_cast(cx, expr, ex, cast_from, cast_to);
             if let ExprKind::Lit(ref lit) = ex.node {
                 use syntax::ast::{LitIntType, LitKind};
+                if let LitKind::Int(n, _) = lit.node {
+                    if cast_to.is_fp() {
+                        let from_nbits = 128 - n.leading_zeros();
+                        let to_nbits = fp_ty_mantissa_nbits(cast_to);
+                        if from_nbits != 0 && to_nbits != 0 && from_nbits <= to_nbits {
+                            span_lint_and_sugg(
+                                cx,
+                                UNNECESSARY_CAST,
+                                expr.span,
+                                &format!("casting integer literal to {} is unnecessary", cast_to),
+                                "try",
+                                format!("{}_{}", n, cast_to),
+                                Applicability::MachineApplicable,
+                            );
+                            return;
+                        }
+                    }
+                }
                 match lit.node {
                     LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::FloatUnsuffixed(_) => {},
                     _ => {
diff --git a/tests/ui/cast.rs b/tests/ui/cast.rs
index c248b5bf598..ab5f9bb4e9d 100644
--- a/tests/ui/cast.rs
+++ b/tests/ui/cast.rs
@@ -8,12 +8,16 @@
 #[allow(clippy::no_effect, clippy::unnecessary_operation)]
 fn main() {
     // Test clippy::cast_precision_loss
-    1i32 as f32;
-    1i64 as f32;
-    1i64 as f64;
-    1u32 as f32;
-    1u64 as f32;
-    1u64 as f64;
+    let x0 = 1i32;
+    x0 as f32;
+    let x1 = 1i64;
+    x1 as f32;
+    x1 as f64;
+    let x2 = 1u32;
+    x2 as f32;
+    let x3 = 1u64;
+    x3 as f32;
+    x3 as f64;
     // Test clippy::cast_possible_truncation
     1f32 as i32;
     1f32 as u32;
@@ -49,6 +53,10 @@ fn main() {
     1f32 as f32;
     false as bool;
     &1i32 as &i32;
+    // casting integer literal to float is unnecessary
+    100 as f32;
+    100 as f64;
+    100_i32 as f64;
     // Should not trigger
     #[rustfmt::skip]
     let v = vec!(1);
diff --git a/tests/ui/cast.stderr b/tests/ui/cast.stderr
index c01393793f1..9923d35832e 100644
--- a/tests/ui/cast.stderr
+++ b/tests/ui/cast.stderr
@@ -1,43 +1,43 @@
 error: casting i32 to f32 causes a loss of precision (i32 is 32 bits wide, but f32's mantissa is only 23 bits wide)
-  --> $DIR/cast.rs:11:5
+  --> $DIR/cast.rs:12:5
    |
-LL |     1i32 as f32;
-   |     ^^^^^^^^^^^
+LL |     x0 as f32;
+   |     ^^^^^^^^^
    |
    = note: `-D clippy::cast-precision-loss` implied by `-D warnings`
 
 error: casting i64 to f32 causes a loss of precision (i64 is 64 bits wide, but f32's mantissa is only 23 bits wide)
-  --> $DIR/cast.rs:12:5
-   |
-LL |     1i64 as f32;
-   |     ^^^^^^^^^^^
-
-error: casting i64 to f64 causes a loss of precision (i64 is 64 bits wide, but f64's mantissa is only 52 bits wide)
-  --> $DIR/cast.rs:13:5
-   |
-LL |     1i64 as f64;
-   |     ^^^^^^^^^^^
-
-error: casting u32 to f32 causes a loss of precision (u32 is 32 bits wide, but f32's mantissa is only 23 bits wide)
   --> $DIR/cast.rs:14:5
    |
-LL |     1u32 as f32;
-   |     ^^^^^^^^^^^
+LL |     x1 as f32;
+   |     ^^^^^^^^^
 
-error: casting u64 to f32 causes a loss of precision (u64 is 64 bits wide, but f32's mantissa is only 23 bits wide)
+error: casting i64 to f64 causes a loss of precision (i64 is 64 bits wide, but f64's mantissa is only 52 bits wide)
   --> $DIR/cast.rs:15:5
    |
-LL |     1u64 as f32;
-   |     ^^^^^^^^^^^
+LL |     x1 as f64;
+   |     ^^^^^^^^^
+
+error: casting u32 to f32 causes a loss of precision (u32 is 32 bits wide, but f32's mantissa is only 23 bits wide)
+  --> $DIR/cast.rs:17:5
+   |
+LL |     x2 as f32;
+   |     ^^^^^^^^^
+
+error: casting u64 to f32 causes a loss of precision (u64 is 64 bits wide, but f32's mantissa is only 23 bits wide)
+  --> $DIR/cast.rs:19:5
+   |
+LL |     x3 as f32;
+   |     ^^^^^^^^^
 
 error: casting u64 to f64 causes a loss of precision (u64 is 64 bits wide, but f64's mantissa is only 52 bits wide)
-  --> $DIR/cast.rs:16:5
+  --> $DIR/cast.rs:20:5
    |
-LL |     1u64 as f64;
-   |     ^^^^^^^^^^^
+LL |     x3 as f64;
+   |     ^^^^^^^^^
 
 error: casting f32 to i32 may truncate the value
-  --> $DIR/cast.rs:18:5
+  --> $DIR/cast.rs:22:5
    |
 LL |     1f32 as i32;
    |     ^^^^^^^^^^^
@@ -45,13 +45,13 @@ LL |     1f32 as i32;
    = note: `-D clippy::cast-possible-truncation` implied by `-D warnings`
 
 error: casting f32 to u32 may truncate the value
-  --> $DIR/cast.rs:19:5
+  --> $DIR/cast.rs:23:5
    |
 LL |     1f32 as u32;
    |     ^^^^^^^^^^^
 
 error: casting f32 to u32 may lose the sign of the value
-  --> $DIR/cast.rs:19:5
+  --> $DIR/cast.rs:23:5
    |
 LL |     1f32 as u32;
    |     ^^^^^^^^^^^
@@ -59,43 +59,43 @@ LL |     1f32 as u32;
    = note: `-D clippy::cast-sign-loss` implied by `-D warnings`
 
 error: casting f64 to f32 may truncate the value
-  --> $DIR/cast.rs:20:5
+  --> $DIR/cast.rs:24:5
    |
 LL |     1f64 as f32;
    |     ^^^^^^^^^^^
 
 error: casting i32 to i8 may truncate the value
-  --> $DIR/cast.rs:21:5
+  --> $DIR/cast.rs:25:5
    |
 LL |     1i32 as i8;
    |     ^^^^^^^^^^
 
 error: casting i32 to u8 may truncate the value
-  --> $DIR/cast.rs:22:5
+  --> $DIR/cast.rs:26:5
    |
 LL |     1i32 as u8;
    |     ^^^^^^^^^^
 
 error: casting f64 to isize may truncate the value
-  --> $DIR/cast.rs:23:5
+  --> $DIR/cast.rs:27:5
    |
 LL |     1f64 as isize;
    |     ^^^^^^^^^^^^^
 
 error: casting f64 to usize may truncate the value
-  --> $DIR/cast.rs:24:5
+  --> $DIR/cast.rs:28:5
    |
 LL |     1f64 as usize;
    |     ^^^^^^^^^^^^^
 
 error: casting f64 to usize may lose the sign of the value
-  --> $DIR/cast.rs:24:5
+  --> $DIR/cast.rs:28:5
    |
 LL |     1f64 as usize;
    |     ^^^^^^^^^^^^^
 
 error: casting u8 to i8 may wrap around the value
-  --> $DIR/cast.rs:26:5
+  --> $DIR/cast.rs:30:5
    |
 LL |     1u8 as i8;
    |     ^^^^^^^^^
@@ -103,31 +103,31 @@ LL |     1u8 as i8;
    = note: `-D clippy::cast-possible-wrap` implied by `-D warnings`
 
 error: casting u16 to i16 may wrap around the value
-  --> $DIR/cast.rs:27:5
+  --> $DIR/cast.rs:31:5
    |
 LL |     1u16 as i16;
    |     ^^^^^^^^^^^
 
 error: casting u32 to i32 may wrap around the value
-  --> $DIR/cast.rs:28:5
+  --> $DIR/cast.rs:32:5
    |
 LL |     1u32 as i32;
    |     ^^^^^^^^^^^
 
 error: casting u64 to i64 may wrap around the value
-  --> $DIR/cast.rs:29:5
+  --> $DIR/cast.rs:33:5
    |
 LL |     1u64 as i64;
    |     ^^^^^^^^^^^
 
 error: casting usize to isize may wrap around the value
-  --> $DIR/cast.rs:30:5
+  --> $DIR/cast.rs:34:5
    |
 LL |     1usize as isize;
    |     ^^^^^^^^^^^^^^^
 
 error: casting f32 to f64 may become silently lossy if types change
-  --> $DIR/cast.rs:32:5
+  --> $DIR/cast.rs:36:5
    |
 LL |     1.0f32 as f64;
    |     ^^^^^^^^^^^^^ help: try: `f64::from(1.0f32)`
@@ -135,25 +135,25 @@ LL |     1.0f32 as f64;
    = note: `-D clippy::cast-lossless` implied by `-D warnings`
 
 error: casting u8 to u16 may become silently lossy if types change
-  --> $DIR/cast.rs:34:5
+  --> $DIR/cast.rs:38:5
    |
 LL |     (1u8 + 1u8) as u16;
    |     ^^^^^^^^^^^^^^^^^^ help: try: `u16::from(1u8 + 1u8)`
 
 error: casting i32 to u32 may lose the sign of the value
-  --> $DIR/cast.rs:37:5
+  --> $DIR/cast.rs:41:5
    |
 LL |     -1i32 as u32;
    |     ^^^^^^^^^^^^
 
 error: casting isize to usize may lose the sign of the value
-  --> $DIR/cast.rs:39:5
+  --> $DIR/cast.rs:43:5
    |
 LL |     -1isize as usize;
    |     ^^^^^^^^^^^^^^^^
 
 error: casting to the same type is unnecessary (`i32` -> `i32`)
-  --> $DIR/cast.rs:48:5
+  --> $DIR/cast.rs:52:5
    |
 LL |     1i32 as i32;
    |     ^^^^^^^^^^^
@@ -161,16 +161,34 @@ LL |     1i32 as i32;
    = note: `-D clippy::unnecessary-cast` implied by `-D warnings`
 
 error: casting to the same type is unnecessary (`f32` -> `f32`)
-  --> $DIR/cast.rs:49:5
+  --> $DIR/cast.rs:53:5
    |
 LL |     1f32 as f32;
    |     ^^^^^^^^^^^
 
 error: casting to the same type is unnecessary (`bool` -> `bool`)
-  --> $DIR/cast.rs:50:5
+  --> $DIR/cast.rs:54:5
    |
 LL |     false as bool;
    |     ^^^^^^^^^^^^^
 
-error: aborting due to 27 previous errors
+error: casting integer literal to f32 is unnecessary
+  --> $DIR/cast.rs:57:5
+   |
+LL |     100 as f32;
+   |     ^^^^^^^^^^ help: try: `100_f32`
+
+error: casting integer literal to f64 is unnecessary
+  --> $DIR/cast.rs:58:5
+   |
+LL |     100 as f64;
+   |     ^^^^^^^^^^ help: try: `100_f64`
+
+error: casting integer literal to f64 is unnecessary
+  --> $DIR/cast.rs:59:5
+   |
+LL |     100_i32 as f64;
+   |     ^^^^^^^^^^^^^^ help: try: `100_f64`
+
+error: aborting due to 30 previous errors
 
diff --git a/tests/ui/cast_lossless_float.fixed b/tests/ui/cast_lossless_float.fixed
index cc3b007ee5d..4df0faf0b3e 100644
--- a/tests/ui/cast_lossless_float.fixed
+++ b/tests/ui/cast_lossless_float.fixed
@@ -5,16 +5,22 @@
 
 fn main() {
     // Test clippy::cast_lossless with casts to floating-point types
-    f32::from(1i8);
-    f64::from(1i8);
-    f32::from(1u8);
-    f64::from(1u8);
-    f32::from(1i16);
-    f64::from(1i16);
-    f32::from(1u16);
-    f64::from(1u16);
-    f64::from(1i32);
-    f64::from(1u32);
+    let x0 = 1i8;
+    f32::from(x0);
+    f64::from(x0);
+    let x1 = 1u8;
+    f32::from(x1);
+    f64::from(x1);
+    let x2 = 1i16;
+    f32::from(x2);
+    f64::from(x2);
+    let x3 = 1u16;
+    f32::from(x3);
+    f64::from(x3);
+    let x4 = 1i32;
+    f64::from(x4);
+    let x5 = 1u32;
+    f64::from(x5);
 }
 
 // The lint would suggest using `f64::from(input)` here but the `XX::from` function is not const,
diff --git a/tests/ui/cast_lossless_float.rs b/tests/ui/cast_lossless_float.rs
index 6684afa0ede..a8d5ed2508c 100644
--- a/tests/ui/cast_lossless_float.rs
+++ b/tests/ui/cast_lossless_float.rs
@@ -5,16 +5,22 @@
 
 fn main() {
     // Test clippy::cast_lossless with casts to floating-point types
-    1i8 as f32;
-    1i8 as f64;
-    1u8 as f32;
-    1u8 as f64;
-    1i16 as f32;
-    1i16 as f64;
-    1u16 as f32;
-    1u16 as f64;
-    1i32 as f64;
-    1u32 as f64;
+    let x0 = 1i8;
+    x0 as f32;
+    x0 as f64;
+    let x1 = 1u8;
+    x1 as f32;
+    x1 as f64;
+    let x2 = 1i16;
+    x2 as f32;
+    x2 as f64;
+    let x3 = 1u16;
+    x3 as f32;
+    x3 as f64;
+    let x4 = 1i32;
+    x4 as f64;
+    let x5 = 1u32;
+    x5 as f64;
 }
 
 // The lint would suggest using `f64::from(input)` here but the `XX::from` function is not const,
diff --git a/tests/ui/cast_lossless_float.stderr b/tests/ui/cast_lossless_float.stderr
index 691ce72399e..942c3d22bdc 100644
--- a/tests/ui/cast_lossless_float.stderr
+++ b/tests/ui/cast_lossless_float.stderr
@@ -1,64 +1,64 @@
 error: casting i8 to f32 may become silently lossy if types change
-  --> $DIR/cast_lossless_float.rs:8:5
+  --> $DIR/cast_lossless_float.rs:9:5
    |
-LL |     1i8 as f32;
-   |     ^^^^^^^^^^ help: try: `f32::from(1i8)`
+LL |     x0 as f32;
+   |     ^^^^^^^^^ help: try: `f32::from(x0)`
    |
    = note: `-D clippy::cast-lossless` implied by `-D warnings`
 
 error: casting i8 to f64 may become silently lossy if types change
-  --> $DIR/cast_lossless_float.rs:9:5
-   |
-LL |     1i8 as f64;
-   |     ^^^^^^^^^^ help: try: `f64::from(1i8)`
-
-error: casting u8 to f32 may become silently lossy if types change
   --> $DIR/cast_lossless_float.rs:10:5
    |
-LL |     1u8 as f32;
-   |     ^^^^^^^^^^ help: try: `f32::from(1u8)`
+LL |     x0 as f64;
+   |     ^^^^^^^^^ help: try: `f64::from(x0)`
 
-error: casting u8 to f64 may become silently lossy if types change
-  --> $DIR/cast_lossless_float.rs:11:5
-   |
-LL |     1u8 as f64;
-   |     ^^^^^^^^^^ help: try: `f64::from(1u8)`
-
-error: casting i16 to f32 may become silently lossy if types change
+error: casting u8 to f32 may become silently lossy if types change
   --> $DIR/cast_lossless_float.rs:12:5
    |
-LL |     1i16 as f32;
-   |     ^^^^^^^^^^^ help: try: `f32::from(1i16)`
+LL |     x1 as f32;
+   |     ^^^^^^^^^ help: try: `f32::from(x1)`
 
-error: casting i16 to f64 may become silently lossy if types change
+error: casting u8 to f64 may become silently lossy if types change
   --> $DIR/cast_lossless_float.rs:13:5
    |
-LL |     1i16 as f64;
-   |     ^^^^^^^^^^^ help: try: `f64::from(1i16)`
+LL |     x1 as f64;
+   |     ^^^^^^^^^ help: try: `f64::from(x1)`
 
-error: casting u16 to f32 may become silently lossy if types change
-  --> $DIR/cast_lossless_float.rs:14:5
-   |
-LL |     1u16 as f32;
-   |     ^^^^^^^^^^^ help: try: `f32::from(1u16)`
-
-error: casting u16 to f64 may become silently lossy if types change
+error: casting i16 to f32 may become silently lossy if types change
   --> $DIR/cast_lossless_float.rs:15:5
    |
-LL |     1u16 as f64;
-   |     ^^^^^^^^^^^ help: try: `f64::from(1u16)`
+LL |     x2 as f32;
+   |     ^^^^^^^^^ help: try: `f32::from(x2)`
 
-error: casting i32 to f64 may become silently lossy if types change
+error: casting i16 to f64 may become silently lossy if types change
   --> $DIR/cast_lossless_float.rs:16:5
    |
-LL |     1i32 as f64;
-   |     ^^^^^^^^^^^ help: try: `f64::from(1i32)`
+LL |     x2 as f64;
+   |     ^^^^^^^^^ help: try: `f64::from(x2)`
+
+error: casting u16 to f32 may become silently lossy if types change
+  --> $DIR/cast_lossless_float.rs:18:5
+   |
+LL |     x3 as f32;
+   |     ^^^^^^^^^ help: try: `f32::from(x3)`
+
+error: casting u16 to f64 may become silently lossy if types change
+  --> $DIR/cast_lossless_float.rs:19:5
+   |
+LL |     x3 as f64;
+   |     ^^^^^^^^^ help: try: `f64::from(x3)`
+
+error: casting i32 to f64 may become silently lossy if types change
+  --> $DIR/cast_lossless_float.rs:21:5
+   |
+LL |     x4 as f64;
+   |     ^^^^^^^^^ help: try: `f64::from(x4)`
 
 error: casting u32 to f64 may become silently lossy if types change
-  --> $DIR/cast_lossless_float.rs:17:5
+  --> $DIR/cast_lossless_float.rs:23:5
    |
-LL |     1u32 as f64;
-   |     ^^^^^^^^^^^ help: try: `f64::from(1u32)`
+LL |     x5 as f64;
+   |     ^^^^^^^^^ help: try: `f64::from(x5)`
 
 error: aborting due to 10 previous errors
 
diff --git a/tests/ui/cast_size.rs b/tests/ui/cast_size.rs
index fde178b1874..611e5a85572 100644
--- a/tests/ui/cast_size.rs
+++ b/tests/ui/cast_size.rs
@@ -9,10 +9,12 @@
 fn main() {
     // Casting from *size
     1isize as i8;
-    1isize as f64;
-    1usize as f64;
-    1isize as f32;
-    1usize as f32;
+    let x0 = 1isize;
+    let x1 = 1usize;
+    x0 as f64;
+    x1 as f64;
+    x0 as f32;
+    x1 as f32;
     1isize as i32;
     1isize as u32;
     1usize as u32;
@@ -26,4 +28,7 @@ fn main() {
     1u32 as usize; // Should not trigger any lint
     1i32 as isize; // Neither should this
     1i32 as usize;
+    // Big integer literal to float
+    999_999_999 as f32;
+    9_999_999_999_999_999usize as f64;
 }
diff --git a/tests/ui/cast_size.stderr b/tests/ui/cast_size.stderr
index a77aafaf11d..735e522b40d 100644
--- a/tests/ui/cast_size.stderr
+++ b/tests/ui/cast_size.stderr
@@ -7,57 +7,57 @@ LL |     1isize as i8;
    = note: `-D clippy::cast-possible-truncation` implied by `-D warnings`
 
 error: casting isize to f64 causes a loss of precision on targets with 64-bit wide pointers (isize is 64 bits wide, but f64's mantissa is only 52 bits wide)
-  --> $DIR/cast_size.rs:12:5
+  --> $DIR/cast_size.rs:14:5
    |
-LL |     1isize as f64;
-   |     ^^^^^^^^^^^^^
+LL |     x0 as f64;
+   |     ^^^^^^^^^
    |
    = note: `-D clippy::cast-precision-loss` implied by `-D warnings`
 
 error: casting usize to f64 causes a loss of precision on targets with 64-bit wide pointers (usize is 64 bits wide, but f64's mantissa is only 52 bits wide)
-  --> $DIR/cast_size.rs:13:5
-   |
-LL |     1usize as f64;
-   |     ^^^^^^^^^^^^^
-
-error: casting isize to f32 causes a loss of precision (isize is 32 or 64 bits wide, but f32's mantissa is only 23 bits wide)
-  --> $DIR/cast_size.rs:14:5
-   |
-LL |     1isize as f32;
-   |     ^^^^^^^^^^^^^
-
-error: casting usize to f32 causes a loss of precision (usize is 32 or 64 bits wide, but f32's mantissa is only 23 bits wide)
   --> $DIR/cast_size.rs:15:5
    |
-LL |     1usize as f32;
-   |     ^^^^^^^^^^^^^
+LL |     x1 as f64;
+   |     ^^^^^^^^^
+
+error: casting isize to f32 causes a loss of precision (isize is 32 or 64 bits wide, but f32's mantissa is only 23 bits wide)
+  --> $DIR/cast_size.rs:16:5
+   |
+LL |     x0 as f32;
+   |     ^^^^^^^^^
+
+error: casting usize to f32 causes a loss of precision (usize is 32 or 64 bits wide, but f32's mantissa is only 23 bits wide)
+  --> $DIR/cast_size.rs:17:5
+   |
+LL |     x1 as f32;
+   |     ^^^^^^^^^
 
 error: casting isize to i32 may truncate the value on targets with 64-bit wide pointers
-  --> $DIR/cast_size.rs:16:5
+  --> $DIR/cast_size.rs:18:5
    |
 LL |     1isize as i32;
    |     ^^^^^^^^^^^^^
 
 error: casting isize to u32 may truncate the value on targets with 64-bit wide pointers
-  --> $DIR/cast_size.rs:17:5
+  --> $DIR/cast_size.rs:19:5
    |
 LL |     1isize as u32;
    |     ^^^^^^^^^^^^^
 
 error: casting usize to u32 may truncate the value on targets with 64-bit wide pointers
-  --> $DIR/cast_size.rs:18:5
+  --> $DIR/cast_size.rs:20:5
    |
 LL |     1usize as u32;
    |     ^^^^^^^^^^^^^
 
 error: casting usize to i32 may truncate the value on targets with 64-bit wide pointers
-  --> $DIR/cast_size.rs:19:5
+  --> $DIR/cast_size.rs:21:5
    |
 LL |     1usize as i32;
    |     ^^^^^^^^^^^^^
 
 error: casting usize to i32 may wrap around the value on targets with 32-bit wide pointers
-  --> $DIR/cast_size.rs:19:5
+  --> $DIR/cast_size.rs:21:5
    |
 LL |     1usize as i32;
    |     ^^^^^^^^^^^^^
@@ -65,40 +65,52 @@ LL |     1usize as i32;
    = note: `-D clippy::cast-possible-wrap` implied by `-D warnings`
 
 error: casting i64 to isize may truncate the value on targets with 32-bit wide pointers
-  --> $DIR/cast_size.rs:21:5
+  --> $DIR/cast_size.rs:23:5
    |
 LL |     1i64 as isize;
    |     ^^^^^^^^^^^^^
 
 error: casting i64 to usize may truncate the value on targets with 32-bit wide pointers
-  --> $DIR/cast_size.rs:22:5
+  --> $DIR/cast_size.rs:24:5
    |
 LL |     1i64 as usize;
    |     ^^^^^^^^^^^^^
 
 error: casting u64 to isize may truncate the value on targets with 32-bit wide pointers
-  --> $DIR/cast_size.rs:23:5
+  --> $DIR/cast_size.rs:25:5
    |
 LL |     1u64 as isize;
    |     ^^^^^^^^^^^^^
 
 error: casting u64 to isize may wrap around the value on targets with 64-bit wide pointers
-  --> $DIR/cast_size.rs:23:5
+  --> $DIR/cast_size.rs:25:5
    |
 LL |     1u64 as isize;
    |     ^^^^^^^^^^^^^
 
 error: casting u64 to usize may truncate the value on targets with 32-bit wide pointers
-  --> $DIR/cast_size.rs:24:5
+  --> $DIR/cast_size.rs:26:5
    |
 LL |     1u64 as usize;
    |     ^^^^^^^^^^^^^
 
 error: casting u32 to isize may wrap around the value on targets with 32-bit wide pointers
-  --> $DIR/cast_size.rs:25:5
+  --> $DIR/cast_size.rs:27:5
    |
 LL |     1u32 as isize;
    |     ^^^^^^^^^^^^^
 
-error: aborting due to 16 previous errors
+error: casting i32 to f32 causes a loss of precision (i32 is 32 bits wide, but f32's mantissa is only 23 bits wide)
+  --> $DIR/cast_size.rs:32:5
+   |
+LL |     999_999_999 as f32;
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: casting usize to f64 causes a loss of precision on targets with 64-bit wide pointers (usize is 64 bits wide, but f64's mantissa is only 52 bits wide)
+  --> $DIR/cast_size.rs:33:5
+   |
+LL |     9_999_999_999_999_999usize as f64;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 18 previous errors
 
diff --git a/tests/ui/float_cmp_const.rs b/tests/ui/float_cmp_const.rs
index 887275c5e88..17ad274bd6d 100644
--- a/tests/ui/float_cmp_const.rs
+++ b/tests/ui/float_cmp_const.rs
@@ -19,7 +19,8 @@ fn main() {
     TWO == ONE;
     TWO != ONE;
     ONE + ONE == TWO;
-    1 as f32 == ONE;
+    let x = 1;
+    x as f32 == ONE;
 
     let v = 0.9;
     v == ONE;
diff --git a/tests/ui/float_cmp_const.stderr b/tests/ui/float_cmp_const.stderr
index 9ec921e536a..0c746e24d12 100644
--- a/tests/ui/float_cmp_const.stderr
+++ b/tests/ui/float_cmp_const.stderr
@@ -48,37 +48,37 @@ LL |     ONE + ONE == TWO;
    |     ^^^^^^^^^^^^^^^^
 
 error: strict comparison of f32 or f64 constant
-  --> $DIR/float_cmp_const.rs:22:5
+  --> $DIR/float_cmp_const.rs:23:5
    |
-LL |     1 as f32 == ONE;
-   |     ^^^^^^^^^^^^^^^ help: consider comparing them within some error: `(1 as f32 - ONE).abs() < error`
+LL |     x as f32 == ONE;
+   |     ^^^^^^^^^^^^^^^ help: consider comparing them within some error: `(x as f32 - ONE).abs() < error`
    |
 note: std::f32::EPSILON and std::f64::EPSILON are available.
-  --> $DIR/float_cmp_const.rs:22:5
+  --> $DIR/float_cmp_const.rs:23:5
    |
-LL |     1 as f32 == ONE;
+LL |     x as f32 == ONE;
    |     ^^^^^^^^^^^^^^^
 
 error: strict comparison of f32 or f64 constant
-  --> $DIR/float_cmp_const.rs:25:5
+  --> $DIR/float_cmp_const.rs:26:5
    |
 LL |     v == ONE;
    |     ^^^^^^^^ help: consider comparing them within some error: `(v - ONE).abs() < error`
    |
 note: std::f32::EPSILON and std::f64::EPSILON are available.
-  --> $DIR/float_cmp_const.rs:25:5
+  --> $DIR/float_cmp_const.rs:26:5
    |
 LL |     v == ONE;
    |     ^^^^^^^^
 
 error: strict comparison of f32 or f64 constant
-  --> $DIR/float_cmp_const.rs:26:5
+  --> $DIR/float_cmp_const.rs:27:5
    |
 LL |     v != ONE;
    |     ^^^^^^^^ help: consider comparing them within some error: `(v - ONE).abs() < error`
    |
 note: std::f32::EPSILON and std::f64::EPSILON are available.
-  --> $DIR/float_cmp_const.rs:26:5
+  --> $DIR/float_cmp_const.rs:27:5
    |
 LL |     v != ONE;
    |     ^^^^^^^^