feat: add on hover to models on lsp (#4351)

Author: benfdking

sqlmesh/lsp/main.py

@@ -15,8 +15,7 @@
 from sqlmesh.lsp.context import LSPContext, ModelTarget
 from sqlmesh.lsp.custom import ALL_MODELS_FEATURE, AllModelsRequest, AllModelsResponse
 from sqlmesh.lsp.reference import (
-    get_model_definitions_for_a_path,
-    filter_references_by_position,
+    get_references,
 )
 
 
@@ -178,6 +177,34 @@ def formatting(
                 ls.show_message(f"Error formatting SQL: {e}", types.MessageType.Error)
                 return []
 
+        @self.server.feature(types.TEXT_DOCUMENT_HOVER)
+        def hover(ls: LanguageServer, params: types.HoverParams) -> t.Optional[types.Hover]:
+            """Provide hover information for an object."""
+            try:
+                self._ensure_context_for_document(params.text_document.uri)
+                document = ls.workspace.get_document(params.text_document.uri)
+                if self.lsp_context is None:
+                    raise RuntimeError(f"No context found for document: {document.path}")
+
+                references = get_references(
+                    self.lsp_context, params.text_document.uri, params.position
+                )
+                if not references:
+                    return None
+                reference = references[0]
+                if not reference.description:
+                    return None
+                return types.Hover(
+                    contents=types.MarkupContent(
+                        kind=types.MarkupKind.Markdown, value=reference.description
+                    ),
+                    range=reference.range,
+                )
+
+            except Exception as e:
+                ls.show_message(f"Error getting hover information: {e}", types.MessageType.Error)
+                return None
+
         @self.server.feature(types.TEXT_DOCUMENT_DEFINITION)
         def goto_definition(
             ls: LanguageServer, params: types.DefinitionParams
@@ -189,10 +216,9 @@ def goto_definition(
                 if self.lsp_context is None:
                     raise RuntimeError(f"No context found for document: {document.path}")
 
-                references = get_model_definitions_for_a_path(
-                    self.lsp_context, params.text_document.uri
+                references = get_references(
+                    self.lsp_context, params.text_document.uri, params.position
                 )
-                filtered_references = filter_references_by_position(references, params.position)
                 return [
                     types.LocationLink(
                         target_uri=reference.uri,
@@ -206,9 +232,8 @@ def goto_definition(
                         ),
                         origin_selection_range=reference.range,
                     )
-                    for reference in filtered_references
+                    for reference in references
                 ]
-
             except Exception as e:
                 ls.show_message(f"Error getting references: {e}", types.MessageType.Error)
                 return []

sqlmesh/lsp/reference.py

@@ -10,40 +10,64 @@
 
 
 class Reference(PydanticModel):
+    """
+    A reference to a model.
+
+    Attributes:
+        range: The range of the reference in the source file
+        uri: The uri of the referenced model
+        description: The description of the referenced model
+    """
+
     range: Range
     uri: str
+    description: t.Optional[str] = None
 
 
-def filter_references_by_position(
-    references: t.List[Reference], position: Position
-) -> t.List[Reference]:
+def by_position(position: Position) -> t.Callable[[Reference], bool]:
     """
-    Filter references to only include those that contain the given position.
+    Filter reference to only filter references that contain the given position.
 
     Args:
-        references: List of Reference objects
         position: The cursor position to check
 
     Returns:
-        List of Reference objects that contain the position
+        A function that returns True if the reference contains the position, False otherwise
     """
-    filtered_references = []
-
-    for reference in references:
-        # Check if position is within the reference range
-        range_start = reference.range.start
-        range_end = reference.range.end
 
-        # Position is within range if it's after or at start and before or at end
-        if (
-            range_start.line < position.line
-            or (range_start.line == position.line and range_start.character <= position.character)
+    def contains_position(r: Reference) -> bool:
+        return (
+            r.range.start.line < position.line
+            or (
+                r.range.start.line == position.line
+                and r.range.start.character <= position.character
+            )
         ) and (
-            range_end.line > position.line
-            or (range_end.line == position.line and range_end.character >= position.character)
-        ):
-            filtered_references.append(reference)
+            r.range.end.line > position.line
+            or (r.range.end.line == position.line and r.range.end.character >= position.character)
+        )
+
+    return contains_position
 
+
+def get_references(
+    lint_context: LSPContext, document_uri: str, position: Position
+) -> t.List[Reference]:
+    """
+    Get references at a specific position in a document.
+
+    Used for hover information.
+
+    Args:
+        lint_context: The LSP context
+        document_uri: The URI of the document
+        position: The position to check for references
+
+    Returns:
+        A list of references at the given position
+    """
+    references = get_model_definitions_for_a_path(lint_context, document_uri)
+    filtered_references = list(filter(by_position(position), references))
     return filtered_references
 
 
@@ -154,7 +178,11 @@ def get_model_definitions_for_a_path(
             start_pos = catalog_or_db_range.start
 
         references.append(
-            Reference(uri=referenced_model_uri, range=Range(start=start_pos, end=end_pos))
+            Reference(
+                uri=referenced_model_uri,
+                range=Range(start=start_pos, end=end_pos),
+                description=referenced_model.description,
+            )
         )
 
     return references

tests/lsp/test_reference.py

@@ -2,7 +2,7 @@
 from lsprotocol.types import Position
 from sqlmesh.core.context import Context
 from sqlmesh.lsp.context import LSPContext, ModelTarget, AuditTarget
-from sqlmesh.lsp.reference import get_model_definitions_for_a_path, filter_references_by_position
+from sqlmesh.lsp.reference import get_model_definitions_for_a_path, by_position
 
 
 @pytest.mark.fast
@@ -54,6 +54,7 @@ def test_reference_with_alias() -> None:
 
     assert references[0].uri.endswith("orders.py")
     assert get_string_from_range(read_file, references[0].range) == "sushi.orders"
+    assert references[0].description == "Table of sushi orders."
     assert references[1].uri.endswith("order_items.py")
     assert get_string_from_range(read_file, references[1].range) == "sushi.order_items"
     assert references[2].uri.endswith("items.py")
@@ -139,7 +140,7 @@ def test_filter_references_by_position() -> None:
         middle_line = (reference.range.start.line + reference.range.end.line) // 2
         middle_char = (reference.range.start.character + reference.range.end.character) // 2
         position_inside = Position(line=middle_line, character=middle_char)
-        filtered = filter_references_by_position(all_references, position_inside)
+        filtered = list(filter(by_position(position_inside), all_references))
         assert len(filtered) == 1
         assert filtered[0].uri == reference.uri
         assert filtered[0].range == reference.range
@@ -155,14 +156,14 @@ def test_filter_references_by_position() -> None:
             outside_char = prev_ref.range.end.character + 5
 
         position_outside = Position(line=outside_line, character=outside_char)
-        filtered_outside = filter_references_by_position(all_references, position_outside)
+        filtered_outside = list(filter(by_position(position_outside), all_references))
         assert reference not in filtered_outside, (
             f"Reference {i} should not match position outside its range"
         )
 
     # Test case: cursor at beginning of file - no references should match
     position_start = Position(line=0, character=0)
-    filtered_start = filter_references_by_position(all_references, position_start)
+    filtered_start = list(filter(by_position(position_start), all_references))
     assert len(filtered_start) == 0 or all(
         ref.range.start.line == 0 and ref.range.start.character <= 0 for ref in filtered_start
     )
@@ -171,7 +172,7 @@ def test_filter_references_by_position() -> None:
     last_line = len(read_file) - 1
     last_char = len(read_file[last_line]) - 1
     position_end = Position(line=last_line, character=last_char)
-    filtered_end = filter_references_by_position(all_references, position_end)
+    filtered_end = list(filter(by_position(position_end), all_references))
     assert len(filtered_end) == 0 or all(
         ref.range.end.line >= last_line and ref.range.end.character >= last_char
         for ref in filtered_end