From c08a2d6d657dc9eddbac00b7789d517b26b9ac3c Mon Sep 17 00:00:00 2001
From: Douglas Creager <dcreager@dcreager.net>
Date: Wed, 8 Oct 2025 15:54:27 -0400
Subject: [PATCH] [ty] Fix hover to prefer expression nodes over identifiers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When hovering on an attribute name like 'value' in 'instance.value',
the minimal covering node is the Identifier, but we need the Attribute
expression to get the type. Update find_covering_node to track both
the minimal node and minimal expression, preferring the expression.

This fixes hover on attribute accesses. All hover tests now pass.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 crates/ty_test/src/hover.rs | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/crates/ty_test/src/hover.rs b/crates/ty_test/src/hover.rs
index 386700b7ea..03e2b52192 100644
--- a/crates/ty_test/src/hover.rs
+++ b/crates/ty_test/src/hover.rs
@@ -26,10 +26,12 @@ pub(crate) struct HoverOutput {
 }
 
 /// Find the AST node with minimal range that fully contains the given offset.
+/// Returns the smallest expression node if possible, skipping over identifier-only nodes.
 fn find_covering_node(root: AnyNodeRef<'_>, offset: TextSize) -> Option<AnyNodeRef<'_>> {
     struct Visitor<'a> {
         offset: TextSize,
         minimal_node: Option<AnyNodeRef<'a>>,
+        minimal_expr: Option<AnyNodeRef<'a>>,
     }
 
     impl<'a> SourceOrderVisitor<'a> for Visitor<'a> {
@@ -43,6 +45,18 @@ fn find_covering_node(root: AnyNodeRef<'_>, offset: TextSize) -> Option<AnyNodeR
                 } else {
                     self.minimal_node = Some(node);
                 }
+
+                // Also track the smallest expression node
+                if node.as_expr_ref().is_some() {
+                    if let Some(current) = self.minimal_expr {
+                        if node.range().len() < current.range().len() {
+                            self.minimal_expr = Some(node);
+                        }
+                    } else {
+                        self.minimal_expr = Some(node);
+                    }
+                }
+
                 TraversalSignal::Traverse
             } else {
                 TraversalSignal::Skip
@@ -53,10 +67,13 @@ fn find_covering_node(root: AnyNodeRef<'_>, offset: TextSize) -> Option<AnyNodeR
     let mut visitor = Visitor {
         offset,
         minimal_node: None,
+        minimal_expr: None,
     };
 
     root.visit_source_order(&mut visitor);
-    visitor.minimal_node
+
+    // Prefer the minimal expression node if we found one, otherwise return the minimal node
+    visitor.minimal_expr.or(visitor.minimal_node)
 }
 
 /// Get the inferred type at a given position in a file.