fix: Improve label on add_missing_match_arms assist

"Fill match arms" is an extremely helpful assist, but the name is
pretty opaque to new users (at least it was to me). We actually
renamed the file in #10299 from
`fill_match_arms.rs` to `add_missing_match_arms.rs` but the label
hasn't changed from its original text in #733.

Instead, show "Add missing match arms" if there are multiple missing
match arms, and show "Add missing match arm `Foo::Bar`" when there's
only a single missing match arm.

Partially generated by Claude Opus.

Author: Wilfred

crates/ide-assists/src/handlers/add_missing_match_arms.rs

@@ -223,9 +223,17 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
         return None;
     }
 
+    let first = missing_pats.next();
+    let label = match (&first, missing_pats.peek()) {
+        (Some((pat, false)), None) => format!("Add missing match arm `{pat}`"),
+        (Some((_, true)), None) => "Add missing match arm `_`".to_owned(),
+        _ => "Add missing match arms".to_owned(),
+    };
+    let missing_pats = first.into_iter().chain(missing_pats);
+
     acc.add(
         AssistId::quick_fix("add_missing_match_arms"),
-        "Fill match arms",
+        label,
         ctx.sema.original_range(match_expr.syntax()).range,
         |builder| {
             // having any hidden variants means that we need a catch-all arm
@@ -635,7 +643,7 @@ mod tests {
     use crate::AssistConfig;
     use crate::tests::{
         TEST_CONFIG, check_assist, check_assist_not_applicable, check_assist_target,
-        check_assist_unresolved, check_assist_with_config,
+        check_assist_unresolved, check_assist_with_config, check_assist_with_label,
     };
 
     use super::add_missing_match_arms;
@@ -1828,8 +1836,10 @@ fn foo(t: Test) {
 
     #[test]
     fn lazy_computation() {
-        // Computing a single missing arm is enough to determine applicability of the assist.
-        cov_mark::check_count!(add_missing_match_arms_lazy_computation, 1);
+        // We compute the first two arms to see if we need a plural in
+        // the label, but otherwise we're lazy.
+        cov_mark::check_count!(add_missing_match_arms_lazy_computation, 2);
+
         check_assist_unresolved(
             add_missing_match_arms,
             r#"
@@ -1841,6 +1851,54 @@ fn foo(tuple: (A, A)) {
         );
     }
 
+    #[test]
+    fn label_single_missing_arm() {
+        check_assist_with_label(
+            add_missing_match_arms,
+            r#"
+enum A { One, Two }
+fn foo(a: A) {
+    match $0a {
+        A::One => {}
+    }
+}
+"#,
+            "Add missing match arm `A::Two`",
+        );
+    }
+
+    #[test]
+    fn label_multiple_missing_arms() {
+        check_assist_with_label(
+            add_missing_match_arms,
+            r#"
+enum A { One, Two, Three }
+fn foo(a: A) {
+    match $0a {}
+}
+"#,
+            "Add missing match arms",
+        );
+    }
+
+    #[test]
+    fn label_catch_all_only() {
+        check_assist_with_label(
+            add_missing_match_arms,
+            r#"
+//- /main.rs crate:main deps:e
+fn foo(t: ::e::E) {
+    match $0t {
+        e::E::A => {}
+    }
+}
+//- /e.rs crate:e
+pub enum E { A, #[doc(hidden)] B, }
+"#,
+            "Add missing match arm `_`",
+        );
+    }
+
     #[test]
     fn adds_comma_before_new_arms() {
         check_assist(

crates/ide-assists/src/tests.rs

@@ -207,6 +207,15 @@ pub(crate) fn check_assist_target(
     check(assist, ra_fixture, ExpectedResult::Target(target), None);
 }
 
+#[track_caller]
+pub(crate) fn check_assist_with_label(
+    assist: Handler,
+    #[rust_analyzer::rust_fixture] ra_fixture: &str,
+    label: &str,
+) {
+    check(assist, ra_fixture, ExpectedResult::Label(label), None);
+}
+
 #[track_caller]
 pub(crate) fn check_assist_not_applicable(
     assist: Handler,
@@ -307,6 +316,7 @@ enum ExpectedResult<'a> {
     Unresolved,
     After(&'a str),
     Target(&'a str),
+    Label(&'a str),
 }
 
 #[track_caller]
@@ -335,7 +345,7 @@ fn check_with_config(
 
     let ctx = AssistContext::new(sema, &config, frange);
     let resolve = match expected {
-        ExpectedResult::Unresolved => AssistResolveStrategy::None,
+        ExpectedResult::Unresolved | ExpectedResult::Label(_) => AssistResolveStrategy::None,
         _ => AssistResolveStrategy::All,
     };
     let mut acc = Assists::new(&ctx, resolve);
@@ -404,14 +414,20 @@ fn check_with_config(
             let range = assist.target;
             assert_eq_text!(&text_without_caret[range], target);
         }
+        (Some(assist), ExpectedResult::Label(label)) => {
+            assert_eq!(assist.label.to_string(), label);
+        }
         (Some(assist), ExpectedResult::Unresolved) => assert!(
             assist.source_change.is_none(),
             "unresolved assist should not contain source changes"
         ),
         (Some(_), ExpectedResult::NotApplicable) => panic!("assist should not be applicable!"),
         (
             None,
-            ExpectedResult::After(_) | ExpectedResult::Target(_) | ExpectedResult::Unresolved,
+            ExpectedResult::After(_)
+            | ExpectedResult::Target(_)
+            | ExpectedResult::Label(_)
+            | ExpectedResult::Unresolved,
         ) => {
             panic!("code action is not applicable")
         }