result-map-unit-fn: use "a" before Result (rust-lang#16593)

changelog: [`result-map-unit-fn`]: use "a" before `Result`

Author: samueltardieu

clippy_lints/src/map_unit_fn.rs

@@ -193,8 +193,10 @@ fn let_binding_name(cx: &LateContext<'_>, var_arg: &hir::Expr<'_>) -> String {
 }
 
 #[must_use]
-fn suggestion_msg(function_type: &str, map_type: &str) -> String {
-    format!("called `map(f)` on an `{map_type}` value where `f` is a {function_type} that returns the unit type `()`")
+fn suggestion_msg(function_type: &str, article: &str, map_type: &str) -> String {
+    format!(
+        "called `map(f)` on {article} `{map_type}` value where `f` is a {function_type} that returns the unit type `()`"
+    )
 }
 
 fn lint_map_unit_fn(
@@ -205,10 +207,10 @@ fn lint_map_unit_fn(
 ) {
     let var_arg = &map_args.0;
 
-    let (map_type, variant, lint) = if cx.typeck_results().expr_ty(var_arg).is_diag_item(cx, sym::Option) {
-        ("Option", "Some", OPTION_MAP_UNIT_FN)
+    let (article, map_type, variant, lint) = if cx.typeck_results().expr_ty(var_arg).is_diag_item(cx, sym::Option) {
+        ("an", "Option", "Some", OPTION_MAP_UNIT_FN)
     } else if cx.typeck_results().expr_ty(var_arg).is_diag_item(cx, sym::Result) {
-        ("Result", "Ok", RESULT_MAP_UNIT_FN)
+        ("a", "Result", "Ok", RESULT_MAP_UNIT_FN)
     } else {
         return;
     };
@@ -219,7 +221,7 @@ fn lint_map_unit_fn(
 
     if is_unit_function(cx, fn_arg) {
         let mut applicability = Applicability::MachineApplicable;
-        let msg = suggestion_msg("function", map_type);
+        let msg = suggestion_msg("function", article, map_type);
         let suggestion = format!(
             "if let {0}({binding}) = {1} {{ {2}({binding}) }}",
             variant,
@@ -232,7 +234,7 @@ fn lint_map_unit_fn(
             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);
+        let msg = suggestion_msg("closure", article, map_type);
 
         span_lint_and_then(cx, lint, expr.span, msg, |diag| {
             if let Some((reduced_expr_span, is_unsafe)) = reduce_unit_expression(cx, closure_expr) {

tests/ui/result_map_unit_fn_fixable.stderr

@@ -1,4 +1,4 @@
-error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type `()`
+error: called `map(f)` on a `Result` value where `f` is a function that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_fixable.rs:32:5
    |
 LL |     x.field.map(do_nothing);
@@ -12,7 +12,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a function that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_fixable.rs:35:5
    |
 LL |     x.field.map(do_nothing);
@@ -24,7 +24,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a function that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_fixable.rs:38:5
    |
 LL |     x.field.map(diverge);
@@ -36,7 +36,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a closure that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_fixable.rs:45:5
    |
 LL |     x.field.map(|value| x.do_result_nothing(value + captured));
@@ -48,7 +48,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a closure that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_fixable.rs:48:5
    |
 LL |     x.field.map(|value| { x.do_result_plus_one(value + captured); });
@@ -60,7 +60,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a closure that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_fixable.rs:52:5
    |
 LL |     x.field.map(|value| do_nothing(value + captured));
@@ -72,7 +72,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a closure that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_fixable.rs:55:5
    |
 LL |     x.field.map(|value| { do_nothing(value + captured) });
@@ -84,7 +84,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a closure that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_fixable.rs:58:5
    |
 LL |     x.field.map(|value| { do_nothing(value + captured); });
@@ -96,7 +96,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a closure that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_fixable.rs:61:5
    |
 LL |     x.field.map(|value| { { do_nothing(value + captured); } });
@@ -108,7 +108,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a closure that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_fixable.rs:65:5
    |
 LL |     x.field.map(|value| diverge(value + captured));
@@ -120,7 +120,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a closure that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_fixable.rs:68:5
    |
 LL |     x.field.map(|value| { diverge(value + captured) });
@@ -132,7 +132,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a closure that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_fixable.rs:71:5
    |
 LL |     x.field.map(|value| { diverge(value + captured); });
@@ -144,7 +144,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a closure that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_fixable.rs:74:5
    |
 LL |     x.field.map(|value| { { diverge(value + captured); } });
@@ -156,7 +156,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a closure that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_fixable.rs:80:5
    |
 LL |     x.field.map(|value| { let y = plus_one(value + captured); });
@@ -168,7 +168,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a closure that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_fixable.rs:83:5
    |
 LL |     x.field.map(|value| { plus_one(value + captured); });
@@ -180,7 +180,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a closure that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_fixable.rs:86:5
    |
 LL |     x.field.map(|value| { { plus_one(value + captured); } });
@@ -192,7 +192,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a closure that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_fixable.rs:90:5
    |
 LL |     x.field.map(|ref value| { do_nothing(value + captured) });
@@ -204,7 +204,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a closure that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_fixable.rs:93:5
    |
 LL |     x.field.map(|value| println!("{value:?}"));

tests/ui/result_map_unit_fn_unfixable.stderr

@@ -1,4 +1,4 @@
-error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
+error: called `map(f)` on a `Result` value where `f` is a closure that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_unfixable.rs:24:5
    |
 LL |     x.field.map(|value| { do_nothing(value); do_nothing(value) });
@@ -12,7 +12,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a closure that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_unfixable.rs:29:5
    |
 LL |     x.field.map(|value| if value > 0 { do_nothing(value); do_nothing(value) });
@@ -24,7 +24,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a closure that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_unfixable.rs:35:5
    |
 LL | /     x.field.map(|value| {
@@ -46,7 +46,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a closure that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_unfixable.rs:41:5
    |
 LL |     x.field.map(|value| { do_nothing(value); do_nothing(value); });
@@ -58,7 +58,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a function that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_unfixable.rs:47:5
    |
 LL |     "12".parse::<i32>().map(diverge);
@@ -70,7 +70,7 @@ 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 `()`
+error: called `map(f)` on a `Result` value where `f` is a function that returns the unit type `()`
   --> tests/ui/result_map_unit_fn_unfixable.rs:55:5
    |
 LL |     y.map(do_nothing);