fix(lsp): narrow hover highlight to keyword tokens for compound expressions

For AwaitExpression, YieldStatement, and UnaryOp(Not), delegate hover
markdown to the inner operand while narrowing the highlight range to
just the keyword token span. This means hovering 'await' in 'await foo()'
shows the hover for foo() but highlights only 'await' — matching user
intuition about which token the tooltip is describing.

HoverResult gains optional Highlight* init overrides; HoverHandler uses
them when set, falling back to the full node span otherwise. TryNarrowToKeyword
runs before GetHoverMarkdownForNode so that 'not p' still produces a
tooltip even though UnaryOp hover is suppressed for builtin operands.

Author: antonsynd

src/Sharpy.Lsp.Tests/HoverServiceTests.cs

@@ -388,4 +388,53 @@ public void GetHoverMarkdown_OnClassBodyWhitespace_ReturnsNull()
 
         hover.Should().BeNull();
     }
+
+    // --- #540 sub-fix B: keyword hover narrows highlight to the keyword span ---
+
+    [Fact]
+    public void GetHoverResult_OverAwaitKeyword_NarrowsHighlightToKeyword()
+    {
+        var source = "async def foo() -> int:\n    return 1\nasync def main():\n    await foo()\n";
+        var result = _api.Analyze(source);
+
+        // Line 4: "    await foo()" — 'await' starts at col 5
+        var hover = _hoverService.GetHoverResult(result, 4, 5);
+
+        hover.Should().NotBeNull();
+        // Highlight narrowed to just "await" (5 chars)
+        hover!.HighlightLineStart.Should().Be(4);
+        hover.HighlightColumnStart.Should().Be(5);
+        hover.HighlightLineEnd.Should().Be(4);
+        hover.HighlightColumnEnd.Should().Be(10);
+    }
+
+    [Fact]
+    public void GetHoverResult_OverAwaitOperand_NoNarrowing()
+    {
+        var source = "async def foo() -> int:\n    return 1\nasync def main():\n    await foo()\n";
+        var result = _api.Analyze(source);
+
+        // Line 4: "    await foo()" — 'foo' starts at col 11
+        var hover = _hoverService.GetHoverResult(result, 4, 11);
+
+        hover.Should().NotBeNull();
+        // Cursor on operand — no narrowing; highlight overrides should be null
+        hover!.HighlightLineStart.Should().BeNull();
+        hover.HighlightColumnStart.Should().BeNull();
+    }
+
+    [Fact]
+    public void GetHoverResult_OverNotKeyword_NarrowsHighlightToKeyword()
+    {
+        var source = "def main():\n    p: bool = True\n    q = not p\n";
+        var result = _api.Analyze(source);
+
+        // Line 3: "    q = not p" — 'not' starts at col 9
+        var hover = _hoverService.GetHoverResult(result, 3, 9);
+
+        hover.Should().NotBeNull();
+        hover!.HighlightLineStart.Should().Be(3);
+        hover.HighlightColumnStart.Should().Be(9);
+        hover.HighlightColumnEnd.Should().Be(12);
+    }
 }

src/Sharpy.Lsp/Handlers/HoverHandler.cs

@@ -33,6 +33,10 @@ public SharpyHoverHandler(LanguageService languageService, HoverService hoverSer
             return null;
 
         var node = result.Node;
+        var startLine = result.HighlightLineStart ?? node.LineStart;
+        var startCol = result.HighlightColumnStart ?? node.ColumnStart;
+        var endLine = result.HighlightLineEnd ?? node.LineEnd;
+        var endCol = result.HighlightColumnEnd ?? node.ColumnEnd;
         return new Hover
         {
             Contents = new MarkedStringsOrMarkupContent(
@@ -43,8 +47,8 @@ public SharpyHoverHandler(LanguageService languageService, HoverService hoverSer
                 }
             ),
             Range = new OmniSharp.Extensions.LanguageServer.Protocol.Models.Range(
-                PositionConverter.ToLsp(node.LineStart, node.ColumnStart),
-                PositionConverter.ToLsp(node.LineEnd, node.ColumnEnd)
+                PositionConverter.ToLsp(startLine, startCol),
+                PositionConverter.ToLsp(endLine, endCol)
             )
         };
     }

src/Sharpy.Lsp/HoverService.cs

@@ -21,9 +21,17 @@ public HoverService(CompilerApi api)
 
     /// <summary>
     /// Result of a hover resolution, containing the markdown content and the AST node
-    /// whose range should be highlighted.
+    /// whose range should be highlighted. Optional Highlight* overrides narrow the
+    /// highlight to a subrange of the node (e.g. the <c>await</c> keyword inside an
+    /// <see cref="AwaitExpression"/>).
     /// </summary>
-    public sealed record HoverResult(string Markdown, Node Node);
+    public sealed record HoverResult(string Markdown, Node Node)
+    {
+        public int? HighlightLineStart { get; init; }
+        public int? HighlightColumnStart { get; init; }
+        public int? HighlightLineEnd { get; init; }
+        public int? HighlightColumnEnd { get; init; }
+    }
 
     /// <summary>
     /// Returns hover markdown for the given position in the analysis result,
@@ -54,13 +62,65 @@ public sealed record HoverResult(string Markdown, Node Node);
         if (node == null)
             return null;
 
+        // Keyword/operator nodes delegate to their operand's hover and narrow the
+        // highlight to the keyword token. Attempt this first so that hovering `not p`
+        // still produces hover text even though builtin UnaryOp hover is suppressed.
+        var narrowed = TryNarrowToKeyword(node, analysis);
+        if (narrowed != null)
+            return narrowed;
+
         var markdown = GetHoverMarkdownForNode(node, analysis, line, col);
         if (markdown == null)
             return null;
 
         return new HoverResult(markdown, node);
     }
 
+    /// <summary>
+    /// For compound expressions whose hover target is a leading keyword/operator token
+    /// (e.g. <c>await foo()</c>, <c>yield x</c>, <c>not p</c>), delegate the hover text
+    /// to the inner operand while narrowing the highlight range to just the keyword
+    /// token span. Returns null when the node is not one of the supported kinds or when
+    /// the inner delegation yields no markdown (in which case callers should keep the
+    /// original result).
+    /// </summary>
+    private HoverResult? TryNarrowToKeyword(Node node, SemanticResult analysis)
+    {
+        Expression? operand;
+        int keywordLength;
+        switch (node)
+        {
+            case AwaitExpression awaitExpr:
+                operand = awaitExpr.Operand;
+                keywordLength = 5; // "await"
+                break;
+            case YieldStatement yieldStmt:
+                if (yieldStmt.Value == null)
+                    return null;
+                operand = yieldStmt.Value;
+                keywordLength = yieldStmt.IsFrom ? 10 : 5; // "yield from" or "yield"
+                break;
+            case UnaryOp { Operator: UnaryOperator.Not } unaryOp:
+                operand = unaryOp.Operand;
+                keywordLength = 3; // "not"
+                break;
+            default:
+                return null;
+        }
+
+        var innerMarkdown = GetHoverMarkdownForNode(operand, analysis, operand.LineStart, operand.ColumnStart);
+        if (innerMarkdown == null)
+            return null;
+
+        return new HoverResult(innerMarkdown, node)
+        {
+            HighlightLineStart = node.LineStart,
+            HighlightColumnStart = node.ColumnStart,
+            HighlightLineEnd = node.LineStart,
+            HighlightColumnEnd = node.ColumnStart + keywordLength,
+        };
+    }
+
     private static bool IsInsideComment(IReadOnlyList<CommentSpan> spans, int line, int col)
     {
         if (spans == null || spans.Count == 0)