Add function that filters kwargs to only those belonging to function definition.

Summary:
In a previous diff a function which added which collects all local kwargs by a given name. This diff creates another helper function which takes those found kwargs and find the function where they are defined. Based on this definition, we are able to select only the keyword arguments that belong to the proper function. This means that if there are multiple kwargs with the same name that belong to different functions, we will be able to narrow the collection of kwargs to only the ones that we intend to rename.

An example might look something like this:

```ptyhon
def main_func(x: int):
    pass

def other_func(x: int):
    pass

main_func(x=100)
```

In the above case, if we rename the x kwarg where `main_func` is called, we would expect that only the x that is part of main_func should be updated. The x that is part of main_func should be left alone even though it shares the same name as the kwarg we are renaming.

This diff also adds a few tests to ensure this this functionality is working properly and we can properly filter kwargs to only those that belong to the function that defines them.

Reviewed By: kinto0

Differential Revision: D86868380

fbshipit-source-id: 385fc8c25f28b767922aba3ed87db5c5af641831

Author: John Van Schultz

pyrefly/lib/state/lsp.rs

@@ -2119,7 +2119,6 @@ impl<'a> Transaction<'a> {
         .unwrap_or_default()
     }
 
-    #[allow(dead_code)]
     pub(self) fn collect_local_keyword_arguments_by_name(
         &self,
         handle: &Handle,
@@ -2153,6 +2152,47 @@ impl<'a> Transaction<'a> {
         results
     }
 
+    #[allow(dead_code)]
+    pub(crate) fn local_keyword_argument_references_from_parameter_definition(
+        &self,
+        handle: &Handle,
+        definition_range: TextRange,
+        expected_name: &Name,
+    ) -> Option<Vec<TextRange>> {
+        let ast = self.get_ast(handle)?;
+        let keyword_args = self.collect_local_keyword_arguments_by_name(handle, expected_name);
+        let mut references = Vec::new();
+
+        let definition_module = self.get_module_info(handle)?;
+
+        for (kw_identifier, callee_kind) in keyword_args {
+            let callee_locations =
+                self.get_callee_location(handle, &callee_kind, &FindPreference::default());
+
+            for TextRangeWithModule {
+                module,
+                range: callee_def_range,
+            } in callee_locations
+            {
+                if module.path() == definition_module.path() {
+                    // Refine to get the actual parameter location
+                    if let Some(param_range) = self.refine_param_location_for_callee(
+                        ast.as_ref(),
+                        callee_def_range,
+                        &kw_identifier,
+                    ) {
+                        // If the parameter location matches our definition, this is a valid reference
+                        if param_range == definition_range {
+                            references.push(kw_identifier.range);
+                        }
+                    }
+                }
+            }
+        }
+
+        Some(references)
+    }
+
     fn local_variable_references_from_local_definition(
         &self,
         handle: &Handle,