Ensure that renaming a keyword argument also updates the names in function calls within the same file.

Summary:
This builds upon the work in previous diffs and implements the local_keyword_argument_referneces_from_parameter_definition in local_references_from_local_definition. In the variable and VariableOrAttribute match arms, we do another check do see if the SymbolKind is either a parameter, variable, or None. If any of these cases are true, we will also include the keyword arguments in the collection that we return.

{F1983467395}

Reviewed By: kinto0

Differential Revision: D86888748

fbshipit-source-id: 2d51165b7d6df1afab8e3c360af332e65ecedd49

Author: John Van Schultz

pyrefly/lib/state/lsp.rs

@@ -2007,14 +2007,15 @@ impl<'a> Transaction<'a> {
                 definition_name,
             ),
             DefinitionMetadata::Module => Vec::new(),
-            DefinitionMetadata::Variable(_) => self
+            DefinitionMetadata::Variable(symbol_kind) => self
                 .local_variable_references_from_local_definition(
                     handle,
                     definition_range,
                     definition_name,
+                    symbol_kind,
                 )
                 .unwrap_or_default(),
-            DefinitionMetadata::VariableOrAttribute(_) => [
+            DefinitionMetadata::VariableOrAttribute(symbol_kind) => [
                 self.local_attribute_references_from_local_definition(
                     handle,
                     definition_range,
@@ -2024,6 +2025,7 @@ impl<'a> Transaction<'a> {
                     handle,
                     definition_range,
                     definition_name,
+                    symbol_kind,
                 )
                 .unwrap_or_default(),
             ]
@@ -2152,7 +2154,6 @@ impl<'a> Transaction<'a> {
         results
     }
 
-    #[allow(dead_code)]
     pub(crate) fn local_keyword_argument_references_from_parameter_definition(
         &self,
         handle: &Handle,
@@ -2198,6 +2199,7 @@ impl<'a> Transaction<'a> {
         handle: &Handle,
         definition_range: TextRange,
         expected_name: &Name,
+        symbol_kind: Option<SymbolKind>,
     ) -> Option<Vec<TextRange>> {
         let mut references = Vec::new();
         if let Some(mod_module) = self.get_ast(handle) {
@@ -2229,6 +2231,21 @@ impl<'a> Transaction<'a> {
             }
             mod_module.visit(&mut |x| f(x, &is_valid_use, &mut references));
         }
+
+        if let Some(kind) = symbol_kind
+            && (kind == SymbolKind::Parameter || kind == SymbolKind::Variable)
+        {
+            let kwarg_references = self
+                .local_keyword_argument_references_from_parameter_definition(
+                    handle,
+                    definition_range,
+                    expected_name,
+                );
+
+            if let Some(refs) = kwarg_references {
+                references.extend(refs);
+            }
+        }
         Some(references)
     }
 

pyrefly/lib/test/lsp/rename.rs

@@ -28,7 +28,7 @@ fn get_test_report(state: &State, handle: &Handle, position: TextSize) -> String
 }
 
 #[test]
-fn test_rename_parameter_does_not_update_keyword_arguments() {
+fn test_rename_parameter_updates_keyword_arguments() {
     let code = r#"
 def greet(name, message):
     """Greet someone with a message."""
@@ -53,6 +53,88 @@ Rename locations:
                             ^^^^
 5 |     return name
                ^^^^
+8 |     result = greet(name="Alice", message="Hello")
+                       ^^^^
+"#
+        .trim(),
+        report.trim(),
+    );
+}
+
+#[test]
+fn test_rename_parameter_only_updates_correct_function() {
+    let code = r#"
+def func1(name, message):
+    """First function with name parameter."""
+    print(f"{message}, {name}!")
+    return name
+
+def func2(name, value):
+    """Second function with same name parameter."""
+    print(f"Value: {value}, Name: {name}")
+    return name
+
+def caller():
+    result1 = func1(name="Alice", message="Hello")
+#                   ^
+    result2 = func2(name="Bob", value=42)
+    return result1, result2
+"#;
+    let report = get_batched_lsp_operations_report(&[("main", code)], get_test_report);
+    assert_eq!(
+        r#"
+# main.py
+13 |     result1 = func1(name="Alice", message="Hello")
+                         ^
+Rename locations:
+2 | def func1(name, message):
+              ^^^^
+4 |     print(f"{message}, {name}!")
+                            ^^^^
+5 |     return name
+               ^^^^
+13 |     result1 = func1(name="Alice", message="Hello")
+                         ^^^^
+"#
+        .trim(),
+        report.trim(),
+    );
+}
+
+#[test]
+fn test_rename_function_parameter_updates_call_sites() {
+    let code = r#"
+def greet(name, message):
+#         ^
+    """Greet someone with a message."""
+    print(f"{message}, {name}!")
+    return name
+
+def caller():
+    result1 = greet(name="Alice", message="Hello")
+    result2 = greet(message="Hi", name="Bob")
+    result3 = greet(name="Charlie", message="Hey")
+    return result1, result2, result3
+"#;
+    let report = get_batched_lsp_operations_report(&[("main", code)], get_test_report);
+    assert_eq!(
+        r#"
+# main.py
+2 | def greet(name, message):
+              ^
+Rename locations:
+2 | def greet(name, message):
+              ^^^^
+5 |     print(f"{message}, {name}!")
+                            ^^^^
+6 |     return name
+               ^^^^
+9 |     result1 = greet(name="Alice", message="Hello")
+                        ^^^^
+10 |     result2 = greet(message="Hi", name="Bob")
+                                       ^^^^
+11 |     result3 = greet(name="Charlie", message="Hey")
+                         ^^^^
 "#
         .trim(),
         report.trim(),