Remove definition_at fallback from get_type_at

Summary:
Remove the `definition_at` method and its usage as a fallback in
`get_type_at`. All definition contexts are now handled explicitly
through `identifier_at` pattern matching, making the scope-trace-based
`definition_at_position` lookup unnecessary.

The KeywordArgument handler now constructs keys directly from the refined
parameter range, with a guard to return None when refinement fails
(i.e., when the text at the definition range doesn't match the keyword
argument name).

Reviewed By: stroxler

Differential Revision: D95331715

fbshipit-source-id: e01f2fdd79eca9c03a33da845f5e3bfda7ceafa4

Author: kinto0

pyrefly/lib/state/lsp.rs

@@ -841,19 +841,7 @@ impl<'a> Transaction<'a> {
         }
     }
 
-    fn definition_at(&self, handle: &Handle, position: TextSize) -> Option<Key> {
-        self.get_bindings(handle)?
-            .definition_at_position(position)
-            .cloned()
-    }
-
     pub fn get_type_at(&self, handle: &Handle, position: TextSize) -> Option<Type> {
-        // TODO(grievejia): Remove the usage of `definition_at()`: it doesn't reliably detect all
-        // definitions.
-        if let Some(key) = self.definition_at(handle, position) {
-            return self.get_type(handle, &key);
-        }
-
         match self.identifier_at(handle, position) {
             Some(IdentifierWithContext {
                 identifier: id,
@@ -991,8 +979,20 @@ impl<'a> Transaction<'a> {
                 )
                 .first()
                 .and_then(|item| {
-                    self.definition_at(handle, item.definition_range.start())
-                        .and_then(|key| self.get_type(handle, &key))
+                    let code_at_range = item.module.code_at(item.definition_range);
+                    // If refinement failed, definition_range points to the callee itself,
+                    // not a matching parameter. In that case, return None.
+                    if code_at_range != identifier.id.as_str() {
+                        return None;
+                    }
+                    let name = Name::new(code_at_range);
+                    let id = Identifier::new(name.clone(), item.definition_range);
+                    let key = Key::Definition(ShortIdentifier::new(&id));
+                    let bindings = self.get_bindings(handle)?;
+                    if !bindings.is_valid_key(&key) {
+                        return None;
+                    }
+                    self.get_type(handle, &key)
                 }),
             Some(IdentifierWithContext {
                 identifier: _,

pyrefly/lib/test/lsp/hover_type.rs

@@ -546,8 +546,8 @@ Hover Result: `int`
     );
 }
 
-// todo(kylei): go-to definition currently finds the implementation in case of overload. it needs to be made smarter
-// for us to know the hover type
+// todo(kylei): When the callee's implementation uses *args/**kwargs, we can't refine the
+// keyword argument to a specific parameter. Ideally we'd resolve through the matched overload.
 #[test]
 fn kwarg_with_overload() {
     let code = r#"