Add hover info for custom types

compiler-core/src/ast.rs

@@ -912,16 +912,17 @@ impl TypedDefinition {
                     .iter()
                     .find(|constructor| constructor.location.contains(byte_index))
                 {
-                    if let Some(annotation) = constructor
+                    return match constructor
                         .arguments
                         .iter()
                         .find(|arg| arg.location.contains(byte_index))
-                        .and_then(|arg| arg.ast.find_node(byte_index, arg.type_.clone()))
                     {
-                        return Some(annotation);
-                    }
-
-                    return Some(Located::VariantConstructorDefinition(constructor));
+                        Some(arg) => match arg.ast.find_node(byte_index, arg.type_.clone()) {
+                            Some(annotation) => Some(annotation),
+                            None => Some(Located::Label(arg.location, arg.type_.clone())),
+                        },
+                        None => Some(Located::VariantConstructorDefinition(constructor)),
+                    };
                 }
 
                 // Note that the custom type `.location` covers the function

compiler-core/src/language_server/engine.rs

@@ -4,6 +4,7 @@ use crate::{
     ast::{
         self, CustomType, Definition, DefinitionLocation, ModuleConstant, PatternUnusedArguments,
         SrcSpan, TypedArg, TypedExpr, TypedFunction, TypedModule, TypedPattern,
+        TypedRecordConstructor,
     },
     build::{Located, Module, UnqualifiedImport, type_constructor_from_modules},
     config::PackageConfig,
@@ -822,6 +823,9 @@ where
                 Located::ModuleStatement(Definition::Function(fun)) => {
                     Some(hover_for_function_head(fun, lines, module))
                 }
+                Located::ModuleStatement(Definition::CustomType(type_)) => {
+                    Some(hover_for_custom_type(type_, lines))
+                }
                 Located::ModuleStatement(Definition::ModuleConstant(constant)) => {
                     Some(hover_for_module_constant(constant, lines, module))
                 }
@@ -837,7 +841,9 @@ where
                     ))
                 }
                 Located::ModuleStatement(_) => None,
-                Located::VariantConstructorDefinition(_) => None,
+                Located::VariantConstructorDefinition(constructor) => {
+                    Some(hover_for_constructor(constructor, lines, module))
+                }
                 Located::UnqualifiedImport(UnqualifiedImport {
                     name,
                     module: module_name,
@@ -1242,6 +1248,53 @@ fn hover_for_module_constant(
     }
 }
 
+fn hover_for_custom_type(type_: &CustomType<Arc<Type>>, line_numbers: LineNumbers) -> Hover {
+    let name = &type_.name;
+    let empty_str = EcoString::from("");
+    let documentation = type_
+        .documentation
+        .as_ref()
+        .map(|(_, doc)| doc)
+        .unwrap_or(&empty_str);
+    let contents = format!("```gleam\n{name}\n```\n{documentation}");
+    Hover {
+        contents: HoverContents::Scalar(MarkedString::String(contents)),
+        range: Some(src_span_to_lsp_range(type_.full_location(), &line_numbers)),
+    }
+}
+
+fn hover_for_constructor(
+    constructor: &TypedRecordConstructor,
+    line_numbers: LineNumbers,
+    module: &Module,
+) -> Hover {
+    let name = &constructor.name;
+    let mut arguments = Vec::with_capacity(constructor.arguments.len());
+    let mut printer = Printer::new(&module.ast.names);
+
+    for argument in &constructor.arguments {
+        let type_ = printer.print_type(&argument.type_);
+        let arg = match argument.label.as_ref() {
+            Some((_, label)) => format!("{label}: {type_}"),
+            None => format!("{type_}"),
+        };
+        arguments.push(arg);
+    }
+
+    let arguments = arguments.join(", ");
+    let empty_str = EcoString::from("");
+    let documentation = constructor
+        .documentation
+        .as_ref()
+        .map(|(_, doc)| doc)
+        .unwrap_or(&empty_str);
+    let contents = format!("```gleam\n{name}({arguments})\n```\n{documentation}");
+    Hover {
+        contents: HoverContents::Scalar(MarkedString::String(contents)),
+        range: Some(src_span_to_lsp_range(constructor.location, &line_numbers)),
+    }
+}
+
 fn hover_for_expression(
     expression: &TypedExpr,
     line_numbers: LineNumbers,

compiler-core/src/language_server/tests/hover.rs

@@ -1589,3 +1589,71 @@ import wibble
         find_position_of("wibble")
     );
 }
+
+#[test]
+fn hover_custom_type() {
+    assert_hover!(
+        "
+/// Exciting documentation
+/// Maybe even multiple lines
+type Wibble {
+    /// Some more exciting documentation
+    Wibble(String)
+    /// The most exciting documentation
+    Wobble(arg: Int)
+}
+",
+        find_position_of("Wibble")
+    );
+}
+
+#[test]
+fn hover_type_constructor() {
+    assert_hover!(
+        "
+/// Exciting documentation
+/// Maybe even multiple lines
+type Wibble {
+    /// Some more exciting documentation
+    Wibble(arg: String)
+    /// The most exciting documentation
+    Wobble(Int)
+}
+",
+        find_position_of("Wibble").nth_occurrence(2)
+    );
+}
+
+#[test]
+fn hover_type_constructor_with_label() {
+    assert_hover!(
+        "
+/// Exciting documentation
+/// Maybe even multiple lines
+type Wibble {
+    /// Some more exciting documentation
+    Wibble(arg: String)
+    /// The most exciting documentation
+    Wobble(Int)
+}
+",
+        find_position_of("Wobble")
+    );
+}
+
+#[test]
+fn hover_for_label_in_type_constructor() {
+    assert_hover!(
+        "
+/// Exciting documentation
+/// Maybe even multiple lines
+type Wibble {
+    /// Some more exciting documentation
+    Wibble(arg: String)
+    /// The most exciting documentation
+    Wobble(Int)
+}
+",
+        find_position_of("arg")
+    );
+}

compiler-core/src/language_server/tests/snapshots/gleam_core__language_server__tests__hover__hover_custom_type.snap

@@ -0,0 +1,26 @@
+---
+source: compiler-core/src/language_server/tests/hover.rs
+expression: "\n/// Exciting documentation\n/// Maybe even multiple lines\ntype Wibble {\n    /// Some more exciting documentation\n    Wibble(String)\n    /// The most exciting documentation\n    Wobble(arg: Int)\n}\n"
+---
+/// Exciting documentation
+/// Maybe even multiple lines
+type Wibble {
+▔▔▔▔▔↑▔▔▔▔▔▔▔
+    /// Some more exciting documentation
+▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+    Wibble(String)
+▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+    /// The most exciting documentation
+▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+    Wobble(arg: Int)
+▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+}
+▔
+
+
+----- Hover content -----
+Scalar(
+    String(
+        "```gleam\nWibble\n```\n Exciting documentation\n Maybe even multiple lines",
+    ),
+)

compiler-core/src/language_server/tests/snapshots/gleam_core__language_server__tests__hover__hover_for_label_in_type_constructor.snap

@@ -0,0 +1,21 @@
+---
+source: compiler-core/src/language_server/tests/hover.rs
+expression: "\n/// Exciting documentation\n/// Maybe even multiple lines\ntype Wibble {\n    /// Some more exciting documentation\n    Wibble(arg: String)\n    /// The most exciting documentation\n    Wobble(Int)\n}\n"
+---
+/// Exciting documentation
+/// Maybe even multiple lines
+type Wibble {
+    /// Some more exciting documentation
+    Wibble(arg: String)
+           ↑▔▔▔▔▔▔▔▔▔▔ 
+    /// The most exciting documentation
+    Wobble(Int)
+}
+
+
+----- Hover content -----
+Scalar(
+    String(
+        "```gleam\nString\n```",
+    ),
+)

compiler-core/src/language_server/tests/snapshots/gleam_core__language_server__tests__hover__hover_type_constructor.snap

@@ -0,0 +1,21 @@
+---
+source: compiler-core/src/language_server/tests/hover.rs
+expression: "\n/// Exciting documentation\n/// Maybe even multiple lines\ntype Wibble {\n    /// Some more exciting documentation\n    Wibble(arg: String)\n    /// The most exciting documentation\n    Wobble(Int)\n}\n"
+---
+/// Exciting documentation
+/// Maybe even multiple lines
+type Wibble {
+    /// Some more exciting documentation
+    Wibble(arg: String)
+    ↑▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+    /// The most exciting documentation
+    Wobble(Int)
+}
+
+
+----- Hover content -----
+Scalar(
+    String(
+        "```gleam\nWibble(arg: String)\n```\n Some more exciting documentation",
+    ),
+)

compiler-core/src/language_server/tests/snapshots/gleam_core__language_server__tests__hover__hover_type_constructor_with_label.snap

@@ -0,0 +1,21 @@
+---
+source: compiler-core/src/language_server/tests/hover.rs
+expression: "\n/// Exciting documentation\n/// Maybe even multiple lines\ntype Wibble {\n    /// Some more exciting documentation\n    Wibble(arg: String)\n    /// The most exciting documentation\n    Wobble(Int)\n}\n"
+---
+/// Exciting documentation
+/// Maybe even multiple lines
+type Wibble {
+    /// Some more exciting documentation
+    Wibble(arg: String)
+    /// The most exciting documentation
+    Wobble(Int)
+    ↑▔▔▔▔▔▔▔▔▔▔
+}
+
+
+----- Hover content -----
+Scalar(
+    String(
+        "```gleam\nWobble(Int)\n```\n The most exciting documentation",
+    ),
+)