[red-knot] Add basic on-hover to playground and LSP (#17057)

## Summary

Implement a very basic hover in the playground and LSP.

It's basic, because it only shows the type on-hover. Most other LSPs
also show:

* The signature of the symbol beneath the cursor. E.g. `class
Test(a:int, b:int)` (we want something like
https://github.com/microsoft/pyright/blob/54f7da25f9c2b6253803602048b04fe0ccb13430/packages/pyright-internal/src/analyzer/typeEvaluator.ts#L21929-L22129)
* The symbols' documentation
* Do more fancy markdown rendering

I decided to defer these features for now because it requires new
semantic APIs (similar to *goto definition*), and investing in fancy
rendering only makes sense once we have the relevant data.

Closes [#16826](#16826)

## Test Plan



https://github.com/user-attachments/assets/044aeee4-58ad-4d4e-9e26-ac2a712026be


https://github.com/user-attachments/assets/4a1f4004-2982-4cf2-9dfd-cb8b84ff2ecb

Author: MichaReiser

crates/red_knot_ide/src/goto.rs

@@ -1,5 +1,6 @@
 use crate::find_node::covering_node;
 use crate::{Db, HasNavigationTargets, NavigationTargets, RangedValue};
+use red_knot_python_semantic::types::Type;
 use red_knot_python_semantic::{HasType, SemanticModel};
 use ruff_db::files::{File, FileRange};
 use ruff_db::parsed::{parsed_module, ParsedModule};
@@ -16,31 +17,7 @@ pub fn goto_type_definition(
     let goto_target = find_goto_target(parsed, offset)?;
 
     let model = SemanticModel::new(db.upcast(), file);
-
-    let ty = match goto_target {
-        GotoTarget::Expression(expression) => expression.inferred_type(&model),
-        GotoTarget::FunctionDef(function) => function.inferred_type(&model),
-        GotoTarget::ClassDef(class) => class.inferred_type(&model),
-        GotoTarget::Parameter(parameter) => parameter.inferred_type(&model),
-        GotoTarget::Alias(alias) => alias.inferred_type(&model),
-        GotoTarget::ExceptVariable(except) => except.inferred_type(&model),
-        GotoTarget::KeywordArgument(argument) => {
-            // TODO: Pyright resolves the declared type of the matching parameter. This seems more accurate
-            // than using the inferred value.
-            argument.value.inferred_type(&model)
-        }
-        // TODO: Support identifier targets
-        GotoTarget::PatternMatchRest(_)
-        | GotoTarget::PatternKeywordArgument(_)
-        | GotoTarget::PatternMatchStarName(_)
-        | GotoTarget::PatternMatchAsName(_)
-        | GotoTarget::ImportedModule(_)
-        | GotoTarget::TypeParamTypeVarName(_)
-        | GotoTarget::TypeParamParamSpecName(_)
-        | GotoTarget::TypeParamTypeVarTupleName(_)
-        | GotoTarget::NonLocal { .. }
-        | GotoTarget::Globals { .. } => return None,
-    };
+    let ty = goto_target.inferred_type(&model)?;
 
     tracing::debug!(
         "Inferred type of covering node is {}",
@@ -149,6 +126,37 @@ pub(crate) enum GotoTarget<'a> {
     },
 }
 
+impl<'db> GotoTarget<'db> {
+    pub(crate) fn inferred_type(self, model: &SemanticModel<'db>) -> Option<Type<'db>> {
+        let ty = match self {
+            GotoTarget::Expression(expression) => expression.inferred_type(model),
+            GotoTarget::FunctionDef(function) => function.inferred_type(model),
+            GotoTarget::ClassDef(class) => class.inferred_type(model),
+            GotoTarget::Parameter(parameter) => parameter.inferred_type(model),
+            GotoTarget::Alias(alias) => alias.inferred_type(model),
+            GotoTarget::ExceptVariable(except) => except.inferred_type(model),
+            GotoTarget::KeywordArgument(argument) => {
+                // TODO: Pyright resolves the declared type of the matching parameter. This seems more accurate
+                // than using the inferred value.
+                argument.value.inferred_type(model)
+            }
+            // TODO: Support identifier targets
+            GotoTarget::PatternMatchRest(_)
+            | GotoTarget::PatternKeywordArgument(_)
+            | GotoTarget::PatternMatchStarName(_)
+            | GotoTarget::PatternMatchAsName(_)
+            | GotoTarget::ImportedModule(_)
+            | GotoTarget::TypeParamTypeVarName(_)
+            | GotoTarget::TypeParamParamSpecName(_)
+            | GotoTarget::TypeParamTypeVarTupleName(_)
+            | GotoTarget::NonLocal { .. }
+            | GotoTarget::Globals { .. } => return None,
+        };
+
+        Some(ty)
+    }
+}
+
 impl Ranged for GotoTarget<'_> {
     fn range(&self) -> TextRange {
         match self {
@@ -174,16 +182,18 @@ impl Ranged for GotoTarget<'_> {
 }
 
 pub(crate) fn find_goto_target(parsed: &ParsedModule, offset: TextSize) -> Option<GotoTarget> {
-    let token = parsed.tokens().at_offset(offset).find(|token| {
-        matches!(
-            token.kind(),
+    let token = parsed
+        .tokens()
+        .at_offset(offset)
+        .max_by_key(|token| match token.kind() {
             TokenKind::Name
-                | TokenKind::String
-                | TokenKind::Complex
-                | TokenKind::Float
-                | TokenKind::Int
-        )
-    })?;
+            | TokenKind::String
+            | TokenKind::Complex
+            | TokenKind::Float
+            | TokenKind::Int => 1,
+            _ => 0,
+        })?;
+
     let covering_node = covering_node(parsed.syntax().into(), token.range())
         .find(|node| node.is_identifier() || node.is_expression())
         .ok()?;
@@ -241,27 +251,18 @@ pub(crate) fn find_goto_target(parsed: &ParsedModule, offset: TextSize) -> Optio
 
 #[cfg(test)]
 mod tests {
-    use std::fmt::Write;
-
-    use crate::db::tests::TestDb;
+    use crate::tests::{cursor_test, CursorTest, IntoDiagnostic};
     use crate::{goto_type_definition, NavigationTarget};
     use insta::assert_snapshot;
-    use insta::internals::SettingsBindDropGuard;
-    use red_knot_python_semantic::{
-        Program, ProgramSettings, PythonPath, PythonPlatform, SearchPathSettings,
-    };
     use ruff_db::diagnostic::{
-        Annotation, Diagnostic, DiagnosticFormat, DiagnosticId, DisplayDiagnosticConfig, LintName,
-        Severity, Span, SubDiagnostic,
+        Annotation, Diagnostic, DiagnosticId, LintName, Severity, Span, SubDiagnostic,
     };
-    use ruff_db::files::{system_path_to_file, File, FileRange};
-    use ruff_db::system::{DbWithWritableSystem, SystemPath, SystemPathBuf};
-    use ruff_python_ast::PythonVersion;
-    use ruff_text_size::{Ranged, TextSize};
+    use ruff_db::files::FileRange;
+    use ruff_text_size::Ranged;
 
     #[test]
     fn goto_type_of_expression_with_class_type() {
-        let test = goto_test(
+        let test = cursor_test(
             r#"
             class Test: ...
 
@@ -291,7 +292,7 @@ mod tests {
 
     #[test]
     fn goto_type_of_expression_with_function_type() {
-        let test = goto_test(
+        let test = cursor_test(
             r#"
             def foo(a, b): ...
 
@@ -323,7 +324,7 @@ mod tests {
 
     #[test]
     fn goto_type_of_expression_with_union_type() {
-        let test = goto_test(
+        let test = cursor_test(
             r#"
 
             def foo(a, b): ...
@@ -380,7 +381,7 @@ mod tests {
 
     #[test]
     fn goto_type_of_expression_with_module() {
-        let mut test = goto_test(
+        let mut test = cursor_test(
             r#"
             import lib
 
@@ -410,7 +411,7 @@ mod tests {
 
     #[test]
     fn goto_type_of_expression_with_literal_type() {
-        let test = goto_test(
+        let test = cursor_test(
             r#"
             a: str = "test"
 
@@ -441,7 +442,7 @@ mod tests {
     }
     #[test]
     fn goto_type_of_expression_with_literal_node() {
-        let test = goto_test(
+        let test = cursor_test(
             r#"
             a: str = "te<CURSOR>st"
             "#,
@@ -469,7 +470,7 @@ mod tests {
 
     #[test]
     fn goto_type_of_expression_with_type_var_type() {
-        let test = goto_test(
+        let test = cursor_test(
             r#"
             type Alias[T: int = bool] = list[T<CURSOR>]
             "#,
@@ -493,7 +494,7 @@ mod tests {
 
     #[test]
     fn goto_type_of_expression_with_type_param_spec() {
-        let test = goto_test(
+        let test = cursor_test(
             r#"
             type Alias[**P = [int, str]] = Callable[P<CURSOR>, int]
             "#,
@@ -507,7 +508,7 @@ mod tests {
 
     #[test]
     fn goto_type_of_expression_with_type_var_tuple() {
-        let test = goto_test(
+        let test = cursor_test(
             r#"
             type Alias[*Ts = ()] = tuple[*Ts<CURSOR>]
             "#,
@@ -521,7 +522,7 @@ mod tests {
 
     #[test]
     fn goto_type_on_keyword_argument() {
-        let test = goto_test(
+        let test = cursor_test(
             r#"
             def test(a: str): ...
 
@@ -553,7 +554,7 @@ mod tests {
 
     #[test]
     fn goto_type_on_incorrectly_typed_keyword_argument() {
-        let test = goto_test(
+        let test = cursor_test(
             r#"
             def test(a: str): ...
 
@@ -588,7 +589,7 @@ mod tests {
 
     #[test]
     fn goto_type_on_kwargs() {
-        let test = goto_test(
+        let test = cursor_test(
             r#"
             def f(name: str): ...
 
@@ -622,14 +623,13 @@ f(**kwargs<CURSOR>)
 
     #[test]
     fn goto_type_of_expression_with_builtin() {
-        let test = goto_test(
+        let test = cursor_test(
             r#"
             def foo(a: str):
                 a<CURSOR>
             "#,
         );
 
-        // FIXME: This should go to `str`
         assert_snapshot!(test.goto_type_definition(), @r###"
         info: lint:goto-type-definition: Type definition
            --> stdlib/builtins.pyi:443:7
@@ -653,7 +653,7 @@ f(**kwargs<CURSOR>)
 
     #[test]
     fn goto_type_definition_cursor_between_object_and_attribute() {
-        let test = goto_test(
+        let test = cursor_test(
             r#"
             class X:
                 def foo(a, b): ...
@@ -685,7 +685,7 @@ f(**kwargs<CURSOR>)
 
     #[test]
     fn goto_between_call_arguments() {
-        let test = goto_test(
+        let test = cursor_test(
             r#"
             def foo(a, b): ...
 
@@ -715,7 +715,7 @@ f(**kwargs<CURSOR>)
 
     #[test]
     fn goto_type_narrowing() {
-        let test = goto_test(
+        let test = cursor_test(
             r#"
             def foo(a: str | None, b):
                 if a is not None:
@@ -747,7 +747,7 @@ f(**kwargs<CURSOR>)
 
     #[test]
     fn goto_type_none() {
-        let test = goto_test(
+        let test = cursor_test(
             r#"
             def foo(a: str | None, b):
                 a<CURSOR>
@@ -792,65 +792,7 @@ f(**kwargs<CURSOR>)
         ");
     }
 
-    fn goto_test(source: &str) -> GotoTest {
-        let mut db = TestDb::new();
-        let cursor_offset = source.find("<CURSOR>").expect(
-            "`source`` should contain a `<CURSOR>` marker, indicating the position of the cursor.",
-        );
-
-        let mut content = source[..cursor_offset].to_string();
-        content.push_str(&source[cursor_offset + "<CURSOR>".len()..]);
-
-        db.write_file("main.py", &content)
-            .expect("write to memory file system to be successful");
-
-        let file = system_path_to_file(&db, "main.py").expect("newly written file to existing");
-
-        Program::from_settings(
-            &db,
-            ProgramSettings {
-                python_version: PythonVersion::latest(),
-                python_platform: PythonPlatform::default(),
-                search_paths: SearchPathSettings {
-                    extra_paths: vec![],
-                    src_roots: vec![SystemPathBuf::from("/")],
-                    custom_typeshed: None,
-                    python_path: PythonPath::KnownSitePackages(vec![]),
-                },
-            },
-        )
-        .expect("Default settings to be valid");
-
-        let mut insta_settings = insta::Settings::clone_current();
-        insta_settings.add_filter(r#"\\(\w\w|\s|\.|")"#, "/$1");
-
-        let insta_settings_guard = insta_settings.bind_to_scope();
-
-        GotoTest {
-            db,
-            cursor_offset: TextSize::try_from(cursor_offset)
-                .expect("source to be smaller than 4GB"),
-            file,
-            _insta_settings_guard: insta_settings_guard,
-        }
-    }
-
-    struct GotoTest {
-        db: TestDb,
-        cursor_offset: TextSize,
-        file: File,
-        _insta_settings_guard: SettingsBindDropGuard,
-    }
-
-    impl GotoTest {
-        fn write_file(
-            &mut self,
-            path: impl AsRef<SystemPath>,
-            content: &str,
-        ) -> std::io::Result<()> {
-            self.db.write_file(path, content)
-        }
-
+    impl CursorTest {
         fn goto_type_definition(&self) -> String {
             let Some(targets) = goto_type_definition(&self.db, self.file, self.cursor_offset)
             else {
@@ -861,19 +803,12 @@ f(**kwargs<CURSOR>)
                 return "No type definitions found".to_string();
             }
 
-            let mut buf = String::new();
-
             let source = targets.range;
-
-            let config = DisplayDiagnosticConfig::default()
-                .color(false)
-                .format(DiagnosticFormat::Full);
-            for target in &*targets {
-                let diag = GotoTypeDefinitionDiagnostic::new(source, target).into_diagnostic();
-                write!(buf, "{}", diag.display(&self.db, &config)).unwrap();
-            }
-
-            buf
+            self.render_diagnostics(
+                targets
+                    .into_iter()
+                    .map(|target| GotoTypeDefinitionDiagnostic::new(source, &target)),
+            )
         }
     }
 
@@ -889,7 +824,9 @@ f(**kwargs<CURSOR>)
                 target: FileRange::new(target.file(), target.focus_range()),
             }
         }
+    }
 
+    impl IntoDiagnostic for GotoTypeDefinitionDiagnostic {
         fn into_diagnostic(self) -> Diagnostic {
             let mut source = SubDiagnostic::new(Severity::Info, "Source");
             source.annotate(Annotation::primary(