Show generic type constructor hovers

Author: CryZe

src/database/queries.rs

@@ -598,6 +598,16 @@ impl CompilerDatabase {
                 StdlibSymbolId::Type(ty.id),
             )));
         }
+        if let TokenKind::Ident(name) = &token.kind
+            && let Some(constructor) = self
+                .context
+                .standard_library()
+                .type_constructor_by_name(name)
+        {
+            return Ok(Some(DefinitionTarget::StandardLibrarySymbol(
+                StdlibSymbolId::TypeConstructor(constructor.id),
+            )));
+        }
         let language = LanguageCatalog::new();
         let item = match &token.kind {
             TokenKind::Ident(name) => language.item_for_source_token(name),

src/insight.rs

@@ -615,7 +615,28 @@ fn render_stdlib_symbol_hover(library: StandardLibrary, symbol: StdlibSymbolId)
         }
         StdlibSymbolId::TypeConstructor(id) => {
             let declaration = library.type_constructor(id);
-            (declaration.name.to_owned(), &declaration.documentation)
+            let mut form = declaration.name.to_owned();
+            if !declaration.parameters.is_empty() {
+                form.push('<');
+                for (index, parameter) in declaration.parameters.iter().enumerate() {
+                    if index != 0 {
+                        form.push_str(", ");
+                    }
+                    form.push_str(parameter.name);
+                    let constraints = library.minimal_capabilities(parameter.constraints);
+                    if !constraints.is_empty() {
+                        form.push_str(": ");
+                        for (constraint_index, constraint) in constraints.iter().enumerate() {
+                            if constraint_index != 0 {
+                                form.push_str(" + ");
+                            }
+                            form.push_str(library.capability(*constraint).name);
+                        }
+                    }
+                }
+                form.push('>');
+            }
+            (form, &declaration.documentation)
         }
         StdlibSymbolId::Type(id) => {
             let declaration = library.type_decl(id);

tests/compiler/sets.rs

@@ -137,6 +137,20 @@ fn set_types_and_methods_are_available_to_editor_queries() {
             && set_offset < highlight.span.end
             && highlight.kind == SemanticTokenKind::Type
     }));
+    let set_hover = database
+        .hover(set_offset + 1)
+        .unwrap()
+        .expect("type-constructor hover");
+    assert!(
+        set_hover
+            .markdown
+            .contains("```splitscript\nSet<T: Equatable>\n```")
+    );
+    assert!(
+        set_hover
+            .markdown
+            .contains("Stores a growable collection of unique values")
+    );
 
     let static_source = r#"
         state "game.exe" {}