fix(lsp): show hover info for string literals and include range in all hovers

String literals were explicitly suppressed from hover (returning null).
Now they fall through to the generic Expression handler like all other
literals, showing their type (str). Also added HoverResult to return
the resolved AST node alongside markdown, enabling the hover handler
to set a Range on all responses so the LSP client highlights the
correct token span.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: antonsynd

src/Sharpy.Lsp.Tests/HoverTests.cs

@@ -423,9 +423,9 @@ public async Task Hover_VariableTypeAnnotation_ShowsTypeInfo()
     }
 
     [Fact]
-    public async Task Hover_StringLiteral_ReturnsNull()
+    public async Task Hover_StringLiteral_ReturnsStringType()
     {
-        // Hovering on a string literal should return null (self-evident type)
+        // Hovering on a string literal should show its type (string)
         var source = "def main():\n    x = \"hello\"";
         _workspace.OpenDocument("file:///test_string_hover.spy", source, 1);
 
@@ -436,12 +436,17 @@ public async Task Hover_StringLiteral_ReturnsNull()
         var node = _api.FindNodeAtPosition(analysis!.Ast!, 2, 9);
         node.Should().NotBeNull();
         node.Should().BeOfType<StringLiteral>();
+
+        var service = new HoverService(_api);
+        var hover = service.GetHoverMarkdown(analysis!, 2, 9);
+        hover.Should().NotBeNull();
+        hover.Should().Contain("str");
     }
 
     [Fact]
-    public async Task Hover_FStringLiteral_ReturnsNull()
+    public async Task Hover_FStringLiteral_ReturnsStringType()
     {
-        // Hovering on an f-string should return null (self-evident type)
+        // Hovering on an f-string should show its type (string)
         var source = "def main():\n    name = \"world\"\n    x = f\"hello {name}\"";
         _workspace.OpenDocument("file:///test_fstring_hover.spy", source, 1);
 
@@ -451,10 +456,12 @@ public async Task Hover_FStringLiteral_ReturnsNull()
         // Line 3: "    x = f\"hello {name}\"" — f-string starts at col 9
         var node = _api.FindNodeAtPosition(analysis!.Ast!, 3, 9);
         node.Should().NotBeNull();
-        // The node should be an FStringLiteral (or contained expression)
         if (node is FStringLiteral)
         {
-            // Hover should suppress for f-strings
+            var service = new HoverService(_api);
+            var hover = service.GetHoverMarkdown(analysis!, 3, 9);
+            hover.Should().NotBeNull();
+            hover.Should().Contain("str");
         }
     }
 

src/Sharpy.Lsp/Handlers/HoverHandler.cs

@@ -28,18 +28,23 @@ public SharpyHoverHandler(LanguageService languageService, HoverService hoverSer
             return null;
 
         var (line, col) = PositionConverter.ToCompiler(request.Position);
-        var hoverMarkdown = _hoverService.GetHoverMarkdown(analysis, line, col);
-        if (hoverMarkdown == null)
+        var result = _hoverService.GetHoverResult(analysis, line, col);
+        if (result == null)
             return null;
 
+        var node = result.Node;
         return new Hover
         {
             Contents = new MarkedStringsOrMarkupContent(
                 new MarkupContent
                 {
                     Kind = MarkupKind.Markdown,
-                    Value = hoverMarkdown
+                    Value = result.Markdown
                 }
+            ),
+            Range = new OmniSharp.Extensions.LanguageServer.Protocol.Models.Range(
+                PositionConverter.ToLsp(node.LineStart, node.ColumnStart),
+                PositionConverter.ToLsp(node.LineEnd, node.ColumnEnd)
             )
         };
     }

src/Sharpy.Lsp/HoverService.cs

@@ -19,12 +19,29 @@ public HoverService(CompilerApi api)
         _api = api;
     }
 
+    /// <summary>
+    /// Result of a hover resolution, containing the markdown content and the AST node
+    /// whose range should be highlighted.
+    /// </summary>
+    public sealed record HoverResult(string Markdown, Node Node);
+
     /// <summary>
     /// Returns hover markdown for the given position in the analysis result,
     /// or null if no hover information is available.
     /// Line and column are 1-based (compiler convention).
     /// </summary>
     public string? GetHoverMarkdown(SemanticResult analysis, int line, int col)
+    {
+        return GetHoverResult(analysis, line, col)?.Markdown;
+    }
+
+    /// <summary>
+    /// Returns hover markdown and the resolved AST node for the given position,
+    /// or null if no hover information is available.
+    /// The node's LineStart/ColumnStart/LineEnd/ColumnEnd can be used to set the hover range.
+    /// Line and column are 1-based (compiler convention).
+    /// </summary>
+    public HoverResult? GetHoverResult(SemanticResult analysis, int line, int col)
     {
         if (analysis.Ast == null || analysis.SemanticQuery == null)
             return null;
@@ -33,7 +50,11 @@ public HoverService(CompilerApi api)
         if (node == null)
             return null;
 
-        return GetHoverMarkdownForNode(node, analysis, line, col);
+        var markdown = GetHoverMarkdownForNode(node, analysis, line, col);
+        if (markdown == null)
+            return null;
+
+        return new HoverResult(markdown, node);
     }
 
     internal string? GetHoverMarkdownForNode(Node node, SemanticResult analysis, int line, int col)
@@ -388,11 +409,6 @@ public HoverService(CompilerApi api)
                     return $"```sharpy\n(module) {fromImport.Module}\n```";
                 }
 
-            // String literals: suppress hover (self-evident type)
-            case StringLiteral:
-            case FStringLiteral:
-                return null;
-
             case Expression expr:
                 {
                     var type = query.GetEffectiveType(expr);