Add a pluralize helper

Summary:
We have three different occurrences of the same pluralization logic now; we might as well consolidate them.

If this gets any more complicated, we should probably look for a library to handle this rather than continuing to reinvent the grammar wheel ^^;

Reviewed By: fangyi-zhou

Differential Revision: D91756391

fbshipit-source-id: cff4a1db4e48c8366bde7dd131c12c760dd6823a

Author: rchen152

crates/pyrefly_util/src/display.rs

@@ -136,14 +136,19 @@ pub fn number_thousands(x: usize) -> impl Display {
         .join(",")
 }
 
+/// Pluralizes by tacking on an "s".
+pub fn pluralize(n: usize, descriptor: &str) -> String {
+    if n == 1 {
+        descriptor.to_owned()
+    } else {
+        format!("{}s", descriptor)
+    }
+}
+
 /// Format the number and descriptor word with the right pluralization.
 /// E.g., count(2, "cat") -> "2 cats". Pluralizes by tacking on an "s".
 pub fn count(n: usize, descriptor: &str) -> String {
-    format!(
-        "{} {descriptor}{}",
-        number_thousands(n),
-        if n == 1 { "" } else { "s" }
-    )
+    format!("{} {}", number_thousands(n), pluralize(n, descriptor))
 }
 
 #[cfg(test)]

pyrefly/lib/alt/callable.rs

@@ -12,6 +12,7 @@ use pyrefly_types::typed_dict::ExtraItems;
 use pyrefly_types::types::TArgs;
 use pyrefly_types::types::TParams;
 use pyrefly_util::display::count;
+use pyrefly_util::display::pluralize;
 use pyrefly_util::owner::Owner;
 use pyrefly_util::prelude::SliceExt;
 use pyrefly_util::prelude::VecExt;
@@ -888,12 +889,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             let range = keywords.first().map_or(arguments_range, |kw| kw.range);
             let msg = if missing_unnamed_posonly == 0 {
                 format!(
-                    "Missing positional argument{} {}",
-                    if missing_named_posonly.len() == 1 {
-                        ""
-                    } else {
-                        "s"
-                    },
+                    "Missing {} {}",
+                    pluralize(missing_named_posonly.len(), "positional argument"),
                     missing_named_posonly
                         .iter()
                         .map(|name| format!("`{name}`"))

pyrefly/lib/alt/solve.rs

@@ -20,6 +20,7 @@ use pyrefly_types::type_info::JoinStyle;
 use pyrefly_types::typed_dict::ExtraItems;
 use pyrefly_types::typed_dict::TypedDict;
 use pyrefly_types::types::Union;
+use pyrefly_util::display::pluralize;
 use pyrefly_util::prelude::SliceExt;
 use pyrefly_util::visit::Visit;
 use pyrefly_util::visit::VisitMut;
@@ -1521,16 +1522,17 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 default.collect_raw_legacy_type_variables(&mut out_of_scope_names);
                 out_of_scope_names.retain(|name| !seen.contains(name));
                 if !out_of_scope_names.is_empty() {
-                    self.error(errors, range, ErrorInfo::Kind(ErrorKind::InvalidTypeVar), format!(
-                        "Default of type parameter `{}` refers to out-of-scope type parameter{} {}",
-                        tparam.quantified.name(),
-                        if out_of_scope_names.len() != 1 {
-                            "s"
-                        } else {
-                            ""
-                        },
-                        out_of_scope_names.map(|n| format!("`{n}`")).join(", "),
-                    ));
+                    self.error(
+                        errors,
+                        range,
+                        ErrorInfo::Kind(ErrorKind::InvalidTypeVar),
+                        format!(
+                            "Default of type parameter `{}` refers to out-of-scope {} {}",
+                            tparam.quantified.name(),
+                            pluralize(out_of_scope_names.len(), "type parameter"),
+                            out_of_scope_names.map(|n| format!("`{n}`")).join(", "),
+                        ),
+                    );
                 }
                 if tparam.quantified.is_type_var()
                     && let Some(tvt) = &typevartuple