[red-knot] LSP and playground hover

Author: MichaReiser

crates/red_knot_ide/src/hover.rs

@@ -0,0 +1,73 @@
+use crate::goto::{find_goto_target, GotoTarget};
+use crate::{Db, 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;
+use ruff_text_size::{Ranged, TextSize};
+
+pub fn hover(db: &dyn Db, file: File, offset: TextSize) -> Option<RangedValue<Hover>> {
+    let parsed = parsed_module(db.upcast(), file);
+    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: Better support for go to type definition in match pattern.
+        // This may require improving type inference (e.g. it currently doesn't handle `...rest`)
+        // but it also requires a new API to query the type because implementing `HasType` for `PatternMatchMapping`
+        // is ambiguous.
+        GotoTarget::PatternMatchRest(_)
+        | GotoTarget::PatternKeywordArgument(_)
+        | GotoTarget::PatternMatchStarName(_)
+        | GotoTarget::PatternMatchAsName(_) => return None,
+
+        // TODO: Resolve the module; The type inference already does all the work
+        // but type isn't stored anywhere. We should either extract the logic
+        // for resolving the module from a ImportFromStmt or store the type during semantic analysis
+        GotoTarget::ImportedModule(_) => return None,
+
+        // Targets without a type definition.
+        GotoTarget::TypeParamTypeVarName(_)
+        | GotoTarget::TypeParamParamSpecName(_)
+        | GotoTarget::TypeParamTypeVarTupleName(_) => return None,
+        GotoTarget::NonLocal { .. } | GotoTarget::Globals { .. } => return None,
+    };
+
+    // TODO: Most LSPs show the symbol declaration: e.g. `class Foo: x: str` instead of just the name of the type
+    // It also seems possible to return more than one markdown element and clients then display all of the
+    // markdown blocks.
+    tracing::debug!(
+        "Inferred type of covering node is {}",
+        ty.display(db.upcast())
+    );
+
+    Some(RangedValue {
+        range: FileRange::new(file, goto_target.range()),
+        value: Hover::Type(ty),
+    })
+}
+
+pub enum Hover<'db> {
+    Type(Type<'db>),
+}
+
+impl Hover<'_> {
+    pub fn to_string(&self, db: &dyn Db) -> String {
+        match self {
+            Hover::Type(ty) => ty.display(db.upcast()).to_string(),
+        }
+    }
+}

crates/red_knot_ide/src/lib.rs

@@ -1,11 +1,13 @@
 mod db;
 mod find_node;
 mod goto;
+mod hover;
 
 use std::ops::{Deref, DerefMut};
 
 pub use db::Db;
 pub use goto::go_to_type_definition;
+pub use hover::hover;
 use red_knot_python_semantic::types::{
     ClassLiteralType, FunctionType, InstanceType, KnownInstanceType, ModuleLiteralType, Type,
 };

crates/red_knot_server/src/server.rs

@@ -7,9 +7,9 @@ use std::panic::PanicInfo;
 
 use lsp_server::Message;
 use lsp_types::{
-    ClientCapabilities, DiagnosticOptions, DiagnosticServerCapabilities, MessageType,
-    ServerCapabilities, TextDocumentSyncCapability, TextDocumentSyncKind, TextDocumentSyncOptions,
-    TypeDefinitionProviderCapability, Url,
+    ClientCapabilities, DiagnosticOptions, DiagnosticServerCapabilities, HoverProviderCapability,
+    MessageType, ServerCapabilities, TextDocumentSyncCapability, TextDocumentSyncKind,
+    TextDocumentSyncOptions, TypeDefinitionProviderCapability, Url,
 };
 
 use self::connection::{Connection, ConnectionInitializer};
@@ -221,6 +221,7 @@ impl Server {
                 },
             )),
             type_definition_provider: Some(TypeDefinitionProviderCapability::Simple(true)),
+            hover_provider: Some(HoverProviderCapability::Simple(true)),
             ..Default::default()
         }
     }

crates/red_knot_server/src/server/api.rs

@@ -32,6 +32,10 @@ pub(super) fn request<'a>(req: server::Request) -> Task<'a> {
                 BackgroundSchedule::LatencySensitive,
             )
         }
+        request::HoverRequestHandler::METHOD => background_request_task::<
+            request::HoverRequestHandler,
+        >(req, BackgroundSchedule::LatencySensitive),
+
         method => {
             tracing::warn!("Received request {method} which does not have a handler");
             return Task::nothing();

crates/red_knot_server/src/server/api/requests.rs

@@ -1,5 +1,7 @@
 mod diagnostic;
 mod goto_type_definition;
+mod hover;
 
 pub(super) use diagnostic::DocumentDiagnosticRequestHandler;
 pub(super) use goto_type_definition::GotoTypeDefinitionRequestHandler;
+pub(super) use hover::HoverRequestHandler;

crates/red_knot_server/src/server/api/requests/hover.rs

@@ -0,0 +1,61 @@
+use std::borrow::Cow;
+
+use crate::document::{PositionExt, ToRangeExt};
+use crate::server::api::traits::{BackgroundDocumentRequestHandler, RequestHandler};
+use crate::server::client::Notifier;
+use crate::DocumentSnapshot;
+use lsp_types::request::HoverRequest;
+use lsp_types::{HoverContents, HoverParams, MarkupContent, MarkupKind, Url};
+use red_knot_ide::hover;
+use red_knot_project::ProjectDatabase;
+use ruff_db::source::{line_index, source_text};
+use ruff_text_size::Ranged;
+
+pub(crate) struct HoverRequestHandler;
+
+impl RequestHandler for HoverRequestHandler {
+    type RequestType = HoverRequest;
+}
+
+impl BackgroundDocumentRequestHandler for HoverRequestHandler {
+    fn document_url(params: &HoverParams) -> Cow<Url> {
+        Cow::Borrowed(&params.text_document_position_params.text_document.uri)
+    }
+
+    fn run_with_snapshot(
+        snapshot: DocumentSnapshot,
+        db: ProjectDatabase,
+        _notifier: Notifier,
+        params: HoverParams,
+    ) -> crate::server::Result<Option<lsp_types::Hover>> {
+        let Some(file) = snapshot.file(&db) else {
+            tracing::debug!("Failed to resolve file for {:?}", params);
+            return Ok(None);
+        };
+
+        let source = source_text(&db, file);
+        let line_index = line_index(&db, file);
+        let offset = params.text_document_position_params.position.to_text_size(
+            &source,
+            &line_index,
+            snapshot.encoding(),
+        );
+
+        let Some(range_info) = hover(&db, file, offset) else {
+            return Ok(None);
+        };
+
+        // TODO: Respect the clients preferred content format
+        Ok(Some(lsp_types::Hover {
+            contents: HoverContents::Markup(MarkupContent {
+                kind: MarkupKind::Markdown,
+                value: format!("```\n{ty}\n```", ty = range_info.to_string(&db)),
+            }),
+            range: Some(range_info.file_range().range().to_range(
+                &source,
+                &line_index,
+                snapshot.encoding(),
+            )),
+        }))
+    }
+}

crates/red_knot_wasm/src/lib.rs

@@ -1,7 +1,7 @@
 use std::any::Any;
 
 use js_sys::{Error, JsString};
-use red_knot_ide::go_to_type_definition;
+use red_knot_ide::{go_to_type_definition, hover};
 use red_knot_project::metadata::options::Options;
 use red_knot_project::metadata::value::ValueSource;
 use red_knot_project::watch::{ChangeEvent, ChangedKind, CreatedKind, DeletedKind};
@@ -243,6 +243,35 @@ impl Workspace {
 
         Ok(links)
     }
+
+    #[wasm_bindgen]
+    pub fn hover(&self, file_id: &FileHandle, position: Position) -> Result<Option<Hover>, Error> {
+        let source = source_text(&self.db, file_id.file);
+        let index = line_index(&self.db, file_id.file);
+
+        let offset = index.offset(
+            OneIndexed::new(position.line).ok_or_else(|| {
+                Error::new("Invalid value `0` for `position.line`. The line index is 1-indexed.")
+            })?,
+            OneIndexed::new(position.column).ok_or_else(|| {
+                Error::new(
+                    "Invalid value `0` for `position.column`. The column index is 1-indexed.",
+                )
+            })?,
+            &source,
+        );
+
+        let Some(range_info) = hover(&self.db, file_id.file, offset) else {
+            return Ok(None);
+        };
+
+        let source_range = Range::from_text_range(range_info.file_range().range(), &index, &source);
+
+        Ok(Some(Hover {
+            markdown: format!("```python\n{}\n```", range_info.to_string(&self.db)),
+            range: source_range,
+        }))
+    }
 }
 
 pub(crate) fn into_error<E: std::fmt::Display>(err: E) -> Error {
@@ -437,6 +466,14 @@ pub struct LocationLink {
     pub origin_selection_range: Option<Range>,
 }
 
+#[wasm_bindgen]
+pub struct Hover {
+    #[wasm_bindgen(getter_with_clone)]
+    pub markdown: String,
+
+    pub range: Range,
+}
+
 #[derive(Debug, Clone)]
 struct WasmSystem {
     fs: MemoryFileSystem,

playground/knot/src/Editor/Editor.tsx

@@ -56,6 +56,7 @@ export default function Editor({
   const disposable = useRef<{
     typeDefinition: IDisposable;
     editorOpener: IDisposable;
+    hover: IDisposable;
   } | null>(null);
   const playgroundState = useRef<PlaygroundServerProps>({
     monaco: null,
@@ -93,6 +94,7 @@ export default function Editor({
     return () => {
       disposable.current?.typeDefinition.dispose();
       disposable.current?.editorOpener.dispose();
+      disposable.current?.hover.dispose();
     };
   }, []);
 
@@ -103,12 +105,17 @@ export default function Editor({
       const server = new PlaygroundServer(playgroundState);
       const typeDefinitionDisposable =
         instance.languages.registerTypeDefinitionProvider("python", server);
+      const hoverDisposable = instance.languages.registerHoverProvider(
+        "python",
+        server,
+      );
       const editorOpenerDisposable =
         instance.editor.registerEditorOpener(server);
 
       disposable.current = {
         typeDefinition: typeDefinitionDisposable,
         editorOpener: editorOpenerDisposable,
+        hover: hoverDisposable,
       };
 
       playgroundState.current.monaco = instance;
@@ -195,10 +202,49 @@ interface PlaygroundServerProps {
 }
 
 class PlaygroundServer
-  implements languages.TypeDefinitionProvider, editor.ICodeEditorOpener
+  implements
+    languages.TypeDefinitionProvider,
+    editor.ICodeEditorOpener,
+    languages.HoverProvider
 {
   constructor(private props: RefObject<PlaygroundServerProps>) {}
 
+  provideHover(
+    model: editor.ITextModel,
+    position: Position,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _token: CancellationToken,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    context?: languages.HoverContext<languages.Hover> | undefined,
+  ): languages.ProviderResult<languages.Hover> {
+    const workspace = this.props.current.workspace;
+
+    const selectedFile = this.props.current.files.selected;
+    if (selectedFile == null) {
+      return;
+    }
+
+    const selectedHandle = this.props.current.files.handles[selectedFile];
+
+    if (selectedHandle == null) {
+      return;
+    }
+
+    const hover = workspace.hover(
+      selectedHandle,
+      new KnotPosition(position.lineNumber, position.column),
+    );
+
+    if (hover == null) {
+      return;
+    }
+
+    return {
+      range: knotRangeToIRange(hover.range),
+      contents: [{ value: hover.markdown, isTrusted: true }],
+    };
+  }
+
   provideTypeDefinition(
     model: editor.ITextModel,
     position: Position,