diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index 681dc2ab5bc0..b07d4fe81f8a 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -214,6 +214,9 @@ fn lint_map_unit_fn(
     };
     let fn_arg = &map_args.1[0];
 
+    #[expect(clippy::items_after_statements, reason = "the const is only used below")]
+    const SUGG_MSG: &str = "use `if let` instead";
+
     if is_unit_function(cx, fn_arg) {
         let mut applicability = Applicability::MachineApplicable;
         let msg = suggestion_msg("function", map_type);
@@ -226,7 +229,7 @@ fn lint_map_unit_fn(
         );
 
         span_lint_and_then(cx, lint, expr.span, msg, |diag| {
-            diag.span_suggestion(stmt.span, "try", suggestion, applicability);
+            diag.span_suggestion_verbose(stmt.span, SUGG_MSG, suggestion, applicability);
         });
     } else if let Some((binding, closure_expr)) = unit_closure(cx, fn_arg) {
         let msg = suggestion_msg("closure", map_type);
@@ -242,7 +245,7 @@ fn lint_map_unit_fn(
                     snippet_with_applicability(cx, var_arg.span, "_", &mut applicability),
                     snippet_with_context(cx, reduced_expr_span, var_arg.span.ctxt(), "_", &mut applicability).0,
                 );
-                diag.span_suggestion(stmt.span, "try", suggestion, applicability);
+                diag.span_suggestion_verbose(stmt.span, SUGG_MSG, suggestion, applicability);
             } else {
                 let suggestion = format!(
                     "if let {0}({1}) = {2} {{ ... }}",
@@ -250,7 +253,7 @@ fn lint_map_unit_fn(
                     snippet(cx, binding.pat.span, "_"),
                     snippet(cx, var_arg.span, "_"),
                 );
-                diag.span_suggestion(stmt.span, "try", suggestion, Applicability::HasPlaceholders);
+                diag.span_suggestion_verbose(stmt.span, SUGG_MSG, suggestion, Applicability::HasPlaceholders);
             }
         });
     }
diff --git a/tests/ui/option_map_unit_fn_fixable.fixed b/tests/ui/option_map_unit_fn_fixable.fixed
index 340be7c7e932..ddba1cd1291f 100644
--- a/tests/ui/option_map_unit_fn_fixable.fixed
+++ b/tests/ui/option_map_unit_fn_fixable.fixed
@@ -1,6 +1,5 @@
 #![warn(clippy::option_map_unit_fn)]
-#![allow(unused)]
-#![allow(clippy::uninlined_format_args, clippy::unnecessary_wraps)]
+#![expect(clippy::unnecessary_wraps)]
 
 fn do_nothing<T>(_: T) {}
 
@@ -98,7 +97,7 @@ fn option_map_unit_fn() {
     if let Some(a) = option() { do_nothing(a) }
     //~^ option_map_unit_fn
 
-    if let Some(value) = option() { println!("{:?}", value) }
+    if let Some(value) = option() { println!("{value:?}") }
     //~^ option_map_unit_fn
 }
 
diff --git a/tests/ui/option_map_unit_fn_fixable.rs b/tests/ui/option_map_unit_fn_fixable.rs
index d902c87379b7..7bd1fe92bdb6 100644
--- a/tests/ui/option_map_unit_fn_fixable.rs
+++ b/tests/ui/option_map_unit_fn_fixable.rs
@@ -1,6 +1,5 @@
 #![warn(clippy::option_map_unit_fn)]
-#![allow(unused)]
-#![allow(clippy::uninlined_format_args, clippy::unnecessary_wraps)]
+#![expect(clippy::unnecessary_wraps)]
 
 fn do_nothing<T>(_: T) {}
 
@@ -98,7 +97,7 @@ fn option_map_unit_fn() {
     option().map(do_nothing);
     //~^ option_map_unit_fn
 
-    option().map(|value| println!("{:?}", value));
+    option().map(|value| println!("{value:?}"));
     //~^ option_map_unit_fn
 }
 
diff --git a/tests/ui/option_map_unit_fn_fixable.stderr b/tests/ui/option_map_unit_fn_fixable.stderr
index 2405aa9a7ccf..70b6985406f4 100644
--- a/tests/ui/option_map_unit_fn_fixable.stderr
+++ b/tests/ui/option_map_unit_fn_fixable.stderr
@@ -1,173 +1,256 @@
 error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:37:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:36:5
    |
 LL |     x.field.map(do_nothing);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(x_field) = x.field { do_nothing(x_field) }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::option-map-unit-fn` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::option_map_unit_fn)]`
+help: use `if let` instead
+   |
+LL -     x.field.map(do_nothing);
+LL +     if let Some(x_field) = x.field { do_nothing(x_field) }
+   |
 
 error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:40:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:39:5
    |
 LL |     x.field.map(do_nothing);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(x_field) = x.field { do_nothing(x_field) }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(do_nothing);
+LL +     if let Some(x_field) = x.field { do_nothing(x_field) }
+   |
 
 error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:43:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:42:5
    |
 LL |     x.field.map(diverge);
-   |     ^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(x_field) = x.field { diverge(x_field) }`
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(diverge);
+LL +     if let Some(x_field) = x.field { diverge(x_field) }
+   |
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:50:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:49:5
    |
 LL |     x.field.map(|value| x.do_option_nothing(value + captured));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(value) = x.field { x.do_option_nothing(value + captured) }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| x.do_option_nothing(value + captured));
+LL +     if let Some(value) = x.field { x.do_option_nothing(value + captured) }
+   |
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:53:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:52:5
    |
 LL |     x.field.map(|value| { x.do_option_plus_one(value + captured); });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(value) = x.field { x.do_option_plus_one(value + captured); }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { x.do_option_plus_one(value + captured); });
+LL +     if let Some(value) = x.field { x.do_option_plus_one(value + captured); }
+   |
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:57:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:56:5
    |
 LL |     x.field.map(|value| do_nothing(value + captured));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(value) = x.field { do_nothing(value + captured) }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| do_nothing(value + captured));
+LL +     if let Some(value) = x.field { do_nothing(value + captured) }
+   |
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:60:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:59:5
    |
 LL |     x.field.map(|value| { do_nothing(value + captured) });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(value) = x.field { do_nothing(value + captured) }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { do_nothing(value + captured) });
+LL +     if let Some(value) = x.field { do_nothing(value + captured) }
+   |
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:63:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:62:5
    |
 LL |     x.field.map(|value| { do_nothing(value + captured); });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(value) = x.field { do_nothing(value + captured); }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { do_nothing(value + captured); });
+LL +     if let Some(value) = x.field { do_nothing(value + captured); }
+   |
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:66:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:65:5
    |
 LL |     x.field.map(|value| { { do_nothing(value + captured); } });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(value) = x.field { do_nothing(value + captured); }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { { do_nothing(value + captured); } });
+LL +     if let Some(value) = x.field { do_nothing(value + captured); }
+   |
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:70:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:69:5
    |
 LL |     x.field.map(|value| diverge(value + captured));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(value) = x.field { diverge(value + captured) }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| diverge(value + captured));
+LL +     if let Some(value) = x.field { diverge(value + captured) }
+   |
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:73:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:72:5
    |
 LL |     x.field.map(|value| { diverge(value + captured) });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(value) = x.field { diverge(value + captured) }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { diverge(value + captured) });
+LL +     if let Some(value) = x.field { diverge(value + captured) }
+   |
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:76:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:75:5
    |
 LL |     x.field.map(|value| { diverge(value + captured); });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(value) = x.field { diverge(value + captured); }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { diverge(value + captured); });
+LL +     if let Some(value) = x.field { diverge(value + captured); }
+   |
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:79:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:78:5
    |
 LL |     x.field.map(|value| { { diverge(value + captured); } });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(value) = x.field { diverge(value + captured); }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { { diverge(value + captured); } });
+LL +     if let Some(value) = x.field { diverge(value + captured); }
+   |
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:85:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:84:5
    |
 LL |     x.field.map(|value| { let y = plus_one(value + captured); });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(value) = x.field { let y = plus_one(value + captured); }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { let y = plus_one(value + captured); });
+LL +     if let Some(value) = x.field { let y = plus_one(value + captured); }
+   |
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:88:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:87:5
    |
 LL |     x.field.map(|value| { plus_one(value + captured); });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(value) = x.field { plus_one(value + captured); }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { plus_one(value + captured); });
+LL +     if let Some(value) = x.field { plus_one(value + captured); }
+   |
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:91:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:90:5
    |
 LL |     x.field.map(|value| { { plus_one(value + captured); } });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(value) = x.field { plus_one(value + captured); }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { { plus_one(value + captured); } });
+LL +     if let Some(value) = x.field { plus_one(value + captured); }
+   |
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:95:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:94:5
    |
 LL |     x.field.map(|ref value| { do_nothing(value + captured) });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(ref value) = x.field { do_nothing(value + captured) }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|ref value| { do_nothing(value + captured) });
+LL +     if let Some(ref value) = x.field { do_nothing(value + captured) }
+   |
 
 error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:98:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:97:5
    |
 LL |     option().map(do_nothing);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(a) = option() { do_nothing(a) }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     option().map(do_nothing);
+LL +     if let Some(a) = option() { do_nothing(a) }
+   |
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:101:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:100:5
+   |
+LL |     option().map(|value| println!("{value:?}"));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     option().map(|value| println!("{value:?}"));
+LL +     if let Some(value) = option() { println!("{value:?}") }
    |
-LL |     option().map(|value| println!("{:?}", value));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(value) = option() { println!("{:?}", value) }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:108:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:107:5
    |
 LL |     x.map(|x| unsafe { f(x) });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(x) = x { unsafe { f(x) } }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.map(|x| unsafe { f(x) });
+LL +     if let Some(x) = x { unsafe { f(x) } }
+   |
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:110:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:109:5
    |
 LL |     x.map(|x| unsafe { { f(x) } });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Some(x) = x { unsafe { f(x) } }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.map(|x| unsafe { { f(x) } });
+LL +     if let Some(x) = x { unsafe { f(x) } }
+   |
 
 error: aborting due to 21 previous errors
 
diff --git a/tests/ui/option_map_unit_fn_unfixable.rs b/tests/ui/option_map_unit_fn_unfixable.rs
index dd2f80fefbee..a6d7ea4a4c8d 100644
--- a/tests/ui/option_map_unit_fn_unfixable.rs
+++ b/tests/ui/option_map_unit_fn_unfixable.rs
@@ -1,5 +1,6 @@
+//@no-rustfix
 #![warn(clippy::option_map_unit_fn)]
-#![allow(unused)]
+#![allow(clippy::unnecessary_wraps, clippy::unnecessary_map_on_constructor)] // only fires before the fix
 
 fn do_nothing<T>(_: T) {}
 
@@ -11,14 +12,19 @@ fn plus_one(value: usize) -> usize {
     value + 1
 }
 
+struct HasOption {
+    field: Option<usize>,
+}
+
 #[rustfmt::skip]
 fn option_map_unit_fn() {
+    let x = HasOption { field: Some(10) };
 
     x.field.map(|value| { do_nothing(value); do_nothing(value) });
-    //~^ ERROR: cannot find value
+    //~^ option_map_unit_fn
 
     x.field.map(|value| if value > 0 { do_nothing(value); do_nothing(value) });
-    //~^ ERROR: cannot find value
+    //~^ option_map_unit_fn
 
     // Suggestion for the let block should be `{ ... }` as it's too difficult to build a
     // proper suggestion for these cases
@@ -26,18 +32,22 @@ fn option_map_unit_fn() {
         do_nothing(value);
         do_nothing(value)
     });
-    //~^^^^ ERROR: cannot find value
+    //~^^^^ option_map_unit_fn
     x.field.map(|value| { do_nothing(value); do_nothing(value); });
-    //~^ ERROR: cannot find value
+    //~^ option_map_unit_fn
 
     // The following should suggest `if let Some(_X) ...` as it's difficult to generate a proper let variable name for them
     Some(42).map(diverge);
+    //~^ option_map_unit_fn
     "12".parse::<i32>().ok().map(diverge);
+    //~^ option_map_unit_fn
     Some(plus_one(1)).map(do_nothing);
+    //~^ option_map_unit_fn
 
     // Should suggest `if let Some(_y) ...` to not override the existing foo variable
     let y = Some(42);
     y.map(do_nothing);
+    //~^ option_map_unit_fn
 }
 
 fn main() {}
diff --git a/tests/ui/option_map_unit_fn_unfixable.stderr b/tests/ui/option_map_unit_fn_unfixable.stderr
index 852785014329..8cc246a38d37 100644
--- a/tests/ui/option_map_unit_fn_unfixable.stderr
+++ b/tests/ui/option_map_unit_fn_unfixable.stderr
@@ -1,27 +1,106 @@
-error[E0425]: cannot find value `x` in this scope
-  --> tests/ui/option_map_unit_fn_unfixable.rs:17:5
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+  --> tests/ui/option_map_unit_fn_unfixable.rs:23:5
    |
 LL |     x.field.map(|value| { do_nothing(value); do_nothing(value) });
-   |     ^ not found in this scope
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::option-map-unit-fn` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::option_map_unit_fn)]`
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { do_nothing(value); do_nothing(value) });
+LL +     if let Some(value) = x.field { ... }
+   |
 
-error[E0425]: cannot find value `x` in this scope
-  --> tests/ui/option_map_unit_fn_unfixable.rs:20:5
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+  --> tests/ui/option_map_unit_fn_unfixable.rs:26:5
    |
 LL |     x.field.map(|value| if value > 0 { do_nothing(value); do_nothing(value) });
-   |     ^ not found in this scope
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| if value > 0 { do_nothing(value); do_nothing(value) });
+LL +     if let Some(value) = x.field { ... }
+   |
 
-error[E0425]: cannot find value `x` in this scope
-  --> tests/ui/option_map_unit_fn_unfixable.rs:25:5
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+  --> tests/ui/option_map_unit_fn_unfixable.rs:31:5
+   |
+LL | /     x.field.map(|value| {
+LL | |         do_nothing(value);
+LL | |         do_nothing(value)
+LL | |     });
+   | |______^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| {
+LL -         do_nothing(value);
+LL -         do_nothing(value)
+LL -     });
+LL +     if let Some(value) = x.field { ... }
    |
-LL |     x.field.map(|value| {
-   |     ^ not found in this scope
 
-error[E0425]: cannot find value `x` in this scope
-  --> tests/ui/option_map_unit_fn_unfixable.rs:30:5
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+  --> tests/ui/option_map_unit_fn_unfixable.rs:36:5
    |
 LL |     x.field.map(|value| { do_nothing(value); do_nothing(value); });
-   |     ^ not found in this scope
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { do_nothing(value); do_nothing(value); });
+LL +     if let Some(value) = x.field { ... }
+   |
+
+error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type `()`
+  --> tests/ui/option_map_unit_fn_unfixable.rs:40:5
+   |
+LL |     Some(42).map(diverge);
+   |     ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     Some(42).map(diverge);
+LL +     if let Some(a) = Some(42) { diverge(a) }
+   |
+
+error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type `()`
+  --> tests/ui/option_map_unit_fn_unfixable.rs:42:5
+   |
+LL |     "12".parse::<i32>().ok().map(diverge);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     "12".parse::<i32>().ok().map(diverge);
+LL +     if let Some(a) = "12".parse::<i32>().ok() { diverge(a) }
+   |
+
+error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type `()`
+  --> tests/ui/option_map_unit_fn_unfixable.rs:44:5
+   |
+LL |     Some(plus_one(1)).map(do_nothing);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     Some(plus_one(1)).map(do_nothing);
+LL +     if let Some(a) = Some(plus_one(1)) { do_nothing(a) }
+   |
+
+error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type `()`
+  --> tests/ui/option_map_unit_fn_unfixable.rs:49:5
+   |
+LL |     y.map(do_nothing);
+   |     ^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     y.map(do_nothing);
+LL +     if let Some(_y) = y { do_nothing(_y) }
+   |
 
-error: aborting due to 4 previous errors
+error: aborting due to 8 previous errors
 
-For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/result_map_unit_fn_fixable.fixed b/tests/ui/result_map_unit_fn_fixable.fixed
index 6bee013c3f47..b810e85a45fa 100644
--- a/tests/ui/result_map_unit_fn_fixable.fixed
+++ b/tests/ui/result_map_unit_fn_fixable.fixed
@@ -1,6 +1,4 @@
 #![warn(clippy::result_map_unit_fn)]
-#![allow(unused)]
-#![allow(clippy::uninlined_format_args)]
 
 fn do_nothing<T>(_: T) {}
 
@@ -92,7 +90,7 @@ fn result_map_unit_fn() {
     if let Ok(ref value) = x.field { do_nothing(value + captured) }
     //~^ result_map_unit_fn
 
-    if let Ok(value) = x.field { println!("{:?}", value) }
+    if let Ok(value) = x.field { println!("{value:?}") }
     //~^ result_map_unit_fn
 }
 
diff --git a/tests/ui/result_map_unit_fn_fixable.rs b/tests/ui/result_map_unit_fn_fixable.rs
index a206cfe6842f..18cd557f0454 100644
--- a/tests/ui/result_map_unit_fn_fixable.rs
+++ b/tests/ui/result_map_unit_fn_fixable.rs
@@ -1,6 +1,4 @@
 #![warn(clippy::result_map_unit_fn)]
-#![allow(unused)]
-#![allow(clippy::uninlined_format_args)]
 
 fn do_nothing<T>(_: T) {}
 
@@ -92,7 +90,7 @@ fn result_map_unit_fn() {
     x.field.map(|ref value| { do_nothing(value + captured) });
     //~^ result_map_unit_fn
 
-    x.field.map(|value| println!("{:?}", value));
+    x.field.map(|value| println!("{value:?}"));
     //~^ result_map_unit_fn
 }
 
diff --git a/tests/ui/result_map_unit_fn_fixable.stderr b/tests/ui/result_map_unit_fn_fixable.stderr
index eca844e06cc0..d8f6239764d1 100644
--- a/tests/ui/result_map_unit_fn_fixable.stderr
+++ b/tests/ui/result_map_unit_fn_fixable.stderr
@@ -1,149 +1,220 @@
 error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:34:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:32:5
    |
 LL |     x.field.map(do_nothing);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(x_field) = x.field { do_nothing(x_field) }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::result-map-unit-fn` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::result_map_unit_fn)]`
+help: use `if let` instead
+   |
+LL -     x.field.map(do_nothing);
+LL +     if let Ok(x_field) = x.field { do_nothing(x_field) }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:37:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:35:5
    |
 LL |     x.field.map(do_nothing);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(x_field) = x.field { do_nothing(x_field) }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(do_nothing);
+LL +     if let Ok(x_field) = x.field { do_nothing(x_field) }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:40:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:38:5
    |
 LL |     x.field.map(diverge);
-   |     ^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(x_field) = x.field { diverge(x_field) }`
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(diverge);
+LL +     if let Ok(x_field) = x.field { diverge(x_field) }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:47:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:45:5
    |
 LL |     x.field.map(|value| x.do_result_nothing(value + captured));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(value) = x.field { x.do_result_nothing(value + captured) }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| x.do_result_nothing(value + captured));
+LL +     if let Ok(value) = x.field { x.do_result_nothing(value + captured) }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:50:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:48:5
    |
 LL |     x.field.map(|value| { x.do_result_plus_one(value + captured); });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(value) = x.field { x.do_result_plus_one(value + captured); }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { x.do_result_plus_one(value + captured); });
+LL +     if let Ok(value) = x.field { x.do_result_plus_one(value + captured); }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:54:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:52:5
    |
 LL |     x.field.map(|value| do_nothing(value + captured));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(value) = x.field { do_nothing(value + captured) }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| do_nothing(value + captured));
+LL +     if let Ok(value) = x.field { do_nothing(value + captured) }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:57:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:55:5
    |
 LL |     x.field.map(|value| { do_nothing(value + captured) });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(value) = x.field { do_nothing(value + captured) }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { do_nothing(value + captured) });
+LL +     if let Ok(value) = x.field { do_nothing(value + captured) }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:60:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:58:5
    |
 LL |     x.field.map(|value| { do_nothing(value + captured); });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(value) = x.field { do_nothing(value + captured); }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { do_nothing(value + captured); });
+LL +     if let Ok(value) = x.field { do_nothing(value + captured); }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:63:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:61:5
    |
 LL |     x.field.map(|value| { { do_nothing(value + captured); } });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(value) = x.field { do_nothing(value + captured); }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { { do_nothing(value + captured); } });
+LL +     if let Ok(value) = x.field { do_nothing(value + captured); }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:67:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:65:5
    |
 LL |     x.field.map(|value| diverge(value + captured));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(value) = x.field { diverge(value + captured) }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| diverge(value + captured));
+LL +     if let Ok(value) = x.field { diverge(value + captured) }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:70:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:68:5
    |
 LL |     x.field.map(|value| { diverge(value + captured) });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(value) = x.field { diverge(value + captured) }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { diverge(value + captured) });
+LL +     if let Ok(value) = x.field { diverge(value + captured) }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:73:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:71:5
    |
 LL |     x.field.map(|value| { diverge(value + captured); });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(value) = x.field { diverge(value + captured); }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { diverge(value + captured); });
+LL +     if let Ok(value) = x.field { diverge(value + captured); }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:76:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:74:5
    |
 LL |     x.field.map(|value| { { diverge(value + captured); } });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(value) = x.field { diverge(value + captured); }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { { diverge(value + captured); } });
+LL +     if let Ok(value) = x.field { diverge(value + captured); }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:82:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:80:5
    |
 LL |     x.field.map(|value| { let y = plus_one(value + captured); });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(value) = x.field { let y = plus_one(value + captured); }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { let y = plus_one(value + captured); });
+LL +     if let Ok(value) = x.field { let y = plus_one(value + captured); }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:85:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:83:5
    |
 LL |     x.field.map(|value| { plus_one(value + captured); });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(value) = x.field { plus_one(value + captured); }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { plus_one(value + captured); });
+LL +     if let Ok(value) = x.field { plus_one(value + captured); }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:88:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:86:5
    |
 LL |     x.field.map(|value| { { plus_one(value + captured); } });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(value) = x.field { plus_one(value + captured); }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { { plus_one(value + captured); } });
+LL +     if let Ok(value) = x.field { plus_one(value + captured); }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:92:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:90:5
    |
 LL |     x.field.map(|ref value| { do_nothing(value + captured) });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(ref value) = x.field { do_nothing(value + captured) }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|ref value| { do_nothing(value + captured) });
+LL +     if let Ok(ref value) = x.field { do_nothing(value + captured) }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:95:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:93:5
+   |
+LL |     x.field.map(|value| println!("{value:?}"));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| println!("{value:?}"));
+LL +     if let Ok(value) = x.field { println!("{value:?}") }
    |
-LL |     x.field.map(|value| println!("{:?}", value));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(value) = x.field { println!("{:?}", value) }`
 
 error: aborting due to 18 previous errors
 
diff --git a/tests/ui/result_map_unit_fn_unfixable.rs b/tests/ui/result_map_unit_fn_unfixable.rs
index fe3d8ece39f4..e3f5c7f996da 100644
--- a/tests/ui/result_map_unit_fn_unfixable.rs
+++ b/tests/ui/result_map_unit_fn_unfixable.rs
@@ -1,7 +1,8 @@
+//@no-rustfix
 #![warn(clippy::result_map_unit_fn)]
 #![feature(never_type)]
-#![allow(unused, clippy::unnecessary_map_on_constructor)]
-//@no-rustfix
+#![allow(clippy::unnecessary_map_on_constructor)]
+
 struct HasResult {
     field: Result<usize, usize>,
 }
diff --git a/tests/ui/result_map_unit_fn_unfixable.stderr b/tests/ui/result_map_unit_fn_unfixable.stderr
index a6e38d808afa..9f80ec1bbbd0 100644
--- a/tests/ui/result_map_unit_fn_unfixable.stderr
+++ b/tests/ui/result_map_unit_fn_unfixable.stderr
@@ -1,58 +1,86 @@
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_unfixable.rs:23:5
+  --> tests/ui/result_map_unit_fn_unfixable.rs:24:5
    |
 LL |     x.field.map(|value| { do_nothing(value); do_nothing(value) });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(value) = x.field { ... }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::result-map-unit-fn` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::result_map_unit_fn)]`
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { do_nothing(value); do_nothing(value) });
+LL +     if let Ok(value) = x.field { ... }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_unfixable.rs:28:5
+  --> tests/ui/result_map_unit_fn_unfixable.rs:29:5
    |
 LL |     x.field.map(|value| if value > 0 { do_nothing(value); do_nothing(value) });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(value) = x.field { ... }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| if value > 0 { do_nothing(value); do_nothing(value) });
+LL +     if let Ok(value) = x.field { ... }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_unfixable.rs:34:5
+  --> tests/ui/result_map_unit_fn_unfixable.rs:35:5
+   |
+LL | /     x.field.map(|value| {
+LL | |
+LL | |
+LL | |         do_nothing(value);
+LL | |         do_nothing(value)
+LL | |     });
+   | |______^
    |
-LL | //     x.field.map(|value| {
-LL | ||
-LL | ||
-LL | ||         do_nothing(value);
-LL | ||         do_nothing(value)
-LL | ||     });
-   | ||______^- help: try: `if let Ok(value) = x.field { ... }`
-   |  |______|
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| {
+LL -
+LL - 
+LL -         do_nothing(value);
+LL -         do_nothing(value)
+LL -     });
+LL +     if let Ok(value) = x.field { ... }
    |
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_unfixable.rs:40:5
+  --> tests/ui/result_map_unit_fn_unfixable.rs:41:5
    |
 LL |     x.field.map(|value| { do_nothing(value); do_nothing(value); });
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(value) = x.field { ... }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     x.field.map(|value| { do_nothing(value); do_nothing(value); });
+LL +     if let Ok(value) = x.field { ... }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_unfixable.rs:46:5
+  --> tests/ui/result_map_unit_fn_unfixable.rs:47:5
    |
 LL |     "12".parse::<i32>().map(diverge);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(a) = "12".parse::<i32>() { diverge(a) }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     "12".parse::<i32>().map(diverge);
+LL +     if let Ok(a) = "12".parse::<i32>() { diverge(a) }
+   |
 
 error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_unfixable.rs:54:5
+  --> tests/ui/result_map_unit_fn_unfixable.rs:55:5
    |
 LL |     y.map(do_nothing);
-   |     ^^^^^^^^^^^^^^^^^-
-   |     |
-   |     help: try: `if let Ok(_y) = y { do_nothing(_y) }`
+   |     ^^^^^^^^^^^^^^^^^
+   |
+help: use `if let` instead
+   |
+LL -     y.map(do_nothing);
+LL +     if let Ok(_y) = y { do_nothing(_y) }
+   |
 
 error: aborting due to 6 previous errors