fix

Author: asukaminato0721

crates/pyrefly_types/src/display.rs

@@ -604,6 +604,47 @@ impl<'a> ClassDisplayContext<'a> {
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct HoverCodeSnippet {
+    pub heading: Option<String>,
+    pub body: String,
+    pub default_kind_label: Option<&'static str>,
+}
+
+pub fn format_hover_code_snippet(
+    type_: &Type,
+    name: Option<&str>,
+    display: String,
+) -> HoverCodeSnippet {
+    if type_.is_function_type() {
+        if let Some(name) = name {
+            let trimmed = display.trim_start();
+            let body = if trimmed.starts_with('(') {
+                format!("def {}{}: ...", name, trimmed)
+            } else {
+                display
+            };
+            HoverCodeSnippet {
+                heading: Some(name.to_owned()),
+                body,
+                default_kind_label: Some("(function) "),
+            }
+        } else {
+            HoverCodeSnippet {
+                heading: None,
+                body: display,
+                default_kind_label: Some("(function) "),
+            }
+        }
+    } else {
+        HoverCodeSnippet {
+            heading: None,
+            body: display,
+            default_kind_label: None,
+        }
+    }
+}
+
 #[cfg(test)]
 pub mod tests {
     use std::path::PathBuf;

pyrefly/lib/lsp/wasm/hover.rs

@@ -21,6 +21,7 @@ use pyrefly_types::callable::Param;
 use pyrefly_types::callable::ParamList;
 use pyrefly_types::callable::Params;
 use pyrefly_types::callable::Required;
+use pyrefly_types::display::format_hover_code_snippet;
 use pyrefly_types::types::BoundMethodType;
 use pyrefly_types::types::Forallable;
 use pyrefly_types::types::Type;
@@ -162,13 +163,6 @@ impl HoverValue {
                 || "".to_owned(),
                 |content| format!("\n---\n{}", content.trim()),
             );
-        let mut kind_formatted = self.kind.map_or("".to_owned(), |kind| {
-            format!("{} ", kind.display_for_hover())
-        });
-        let name_formatted = self
-            .name
-            .as_ref()
-            .map_or("".to_owned(), |s| format!("{s}: "));
         let symbol_def_formatted = if self.show_go_to_links {
             HoverValue::format_symbol_def_locations(&self.type_).unwrap_or("".to_owned())
         } else {
@@ -178,35 +172,32 @@ impl HoverValue {
             .display
             .clone()
             .unwrap_or_else(|| self.type_.as_hover_string());
-
-        let is_function = self.type_.is_function_type();
-        if is_function && kind_formatted.trim().is_empty() {
-            kind_formatted = "(function) ".to_owned();
-        }
-        let trimmed_type_display = type_display.trim_start();
-        let needs_def_wrapper = trimmed_type_display.starts_with('(');
-        let (heading, body) = if is_function {
-            let function_name = self.name.clone().unwrap_or_else(|| "function".to_owned());
-            let heading = format!("{}{}\n", kind_formatted, function_name);
-            let body = if needs_def_wrapper {
-                format!("def {}{}: ...", function_name, trimmed_type_display)
-            } else {
-                type_display
-            };
-            (heading, body)
+        let snippet = format_hover_code_snippet(&self.type_, self.name.as_deref(), type_display);
+        let kind_formatted = self.kind.map_or_else(
+            || {
+                snippet
+                    .default_kind_label
+                    .map(str::to_owned)
+                    .unwrap_or_default()
+            },
+            |kind| format!("{} ", kind.display_for_hover()),
+        );
+        let name_formatted = self
+            .name
+            .as_ref()
+            .map_or("".to_owned(), |s| format!("{s}: "));
+        let heading = if let Some(callable_heading) = snippet.heading.as_ref() {
+            format!("{}{}\n", kind_formatted, callable_heading)
         } else {
-            (
-                format!("{}{}", kind_formatted, name_formatted),
-                type_display,
-            )
+            format!("{}{}", kind_formatted, name_formatted)
         };
 
         Hover {
             contents: HoverContents::Markup(MarkupContent {
                 kind: MarkupKind::Markdown,
                 value: format!(
                     "```python\n{}{}\n```{}{}",
-                    heading, body, docstring_formatted, symbol_def_formatted
+                    heading, snippet.body, docstring_formatted, symbol_def_formatted
                 ),
             }),
             range: None,