[ty] de-dupe ref matching

Author: Hugo-Polloli

crates/ty_ide/src/references.rs

@@ -274,6 +274,49 @@ fn navigation_targets_intersect(
     })
 }
 
+fn covering_node_for_identifier<'a>(
+    target_text: &str,
+    ancestors: &[AnyNodeRef<'a>],
+    identifier: &'a ast::Identifier,
+) -> Option<CoveringNode<'a>> {
+    // Quick text-based check first
+    if identifier.id != target_text {
+        return None;
+    }
+
+    let mut ancestors_with_identifier = ancestors.to_vec();
+    ancestors_with_identifier.push(AnyNodeRef::from(identifier));
+    Some(CoveringNode::from_ancestors(ancestors_with_identifier))
+}
+
+fn covering_node_matches_target_definitions(
+    model: &SemanticModel<'_>,
+    tokens: &Tokens,
+    mode: ReferencesMode,
+    target_definitions: &NavigationTargets,
+    covering_node: &CoveringNode<'_>,
+) -> bool {
+    // Use the start of the covering node as the offset. Any offset within
+    // the node is fine here. Offsets matter only for import statements
+    // where the identifier might be a multi-part module name.
+    let offset = covering_node.node().start();
+    let Some(goto_target) = GotoTarget::from_covering_node(model, covering_node, offset, tokens)
+    else {
+        return false;
+    };
+
+    // Get the definitions for this goto target
+    let Some(current_definitions) = goto_target
+        .get_definition_targets(model, mode.to_import_alias_resolution())
+        .and_then(|definitions| definitions.declaration_targets(model.db()))
+    else {
+        return false;
+    };
+
+    // Check if any of the current definitions match our target definitions
+    navigation_targets_intersect(target_definitions, &current_definitions)
+}
+
 /// Find all references to a local symbol within the current file.
 /// The behavior depends on the provided mode.
 fn references_for_file(
@@ -553,41 +596,28 @@ impl LocalReferencesFinder<'_> {
 
     /// Helper method to check identifier references for declarations
     fn check_identifier_reference(&mut self, identifier: &ast::Identifier) {
-        // Quick text-based check first
-        if identifier.id != self.target_text {
-            return;
+        if let Some(covering_node) =
+            covering_node_for_identifier(self.target_text, &self.ancestors, identifier)
+        {
+            self.check_reference_from_covering_node(&covering_node);
         }
-
-        let mut ancestors_with_identifier = self.ancestors.clone();
-        ancestors_with_identifier.push(AnyNodeRef::from(identifier));
-        let covering_node = CoveringNode::from_ancestors(ancestors_with_identifier);
-        self.check_reference_from_covering_node(&covering_node);
     }
 
     /// Determines whether the given covering node is a reference to
     /// the symbol we are searching for
     fn check_reference_from_covering_node(&mut self, covering_node: &CoveringNode<'_>) {
-        // Use the start of the covering node as the offset. Any offset within
-        // the node is fine here. Offsets matter only for import statements
-        // where the identifier might be a multi-part module name.
-        let offset = covering_node.node().start();
-        if let Some(goto_target) =
-            GotoTarget::from_covering_node(self.model, covering_node, offset, self.tokens)
-        {
-            // Get the definitions for this goto target
-            if let Some(current_definitions) = goto_target
-                .get_definition_targets(self.model, self.mode.to_import_alias_resolution())
-                .and_then(|definitions| definitions.declaration_targets(self.model.db()))
-            {
-                // Check if any of the current definitions match our target definitions
-                if navigation_targets_intersect(self.target_definitions, &current_definitions) {
-                    // Determine if this is a read or write reference
-                    let kind = self.determine_reference_kind(covering_node);
-                    let target =
-                        ReferenceTarget::new(self.model.file(), covering_node.node().range(), kind);
-                    self.references.push(target);
-                }
-            }
+        if covering_node_matches_target_definitions(
+            self.model,
+            self.tokens,
+            self.mode,
+            self.target_definitions,
+            covering_node,
+        ) {
+            // Determine if this is a read or write reference
+            let kind = self.determine_reference_kind(covering_node);
+            let target =
+                ReferenceTarget::new(self.model.file(), covering_node.node().range(), kind);
+            self.references.push(target);
         }
     }
 
@@ -695,34 +725,27 @@ impl LocalReferencesFinder<'_> {
 
 impl KeywordArgumentReferencesFinder<'_> {
     fn check_identifier_reference(&mut self, identifier: &ast::Identifier) {
-        if identifier.id != self.target_text {
-            return;
+        if let Some(covering_node) =
+            covering_node_for_identifier(self.target_text, &self.ancestors, identifier)
+        {
+            self.check_reference_from_covering_node(&covering_node);
         }
-
-        let mut ancestors_with_identifier = self.ancestors.clone();
-        ancestors_with_identifier.push(AnyNodeRef::from(identifier));
-        let covering_node = CoveringNode::from_ancestors(ancestors_with_identifier);
-        self.check_reference_from_covering_node(&covering_node);
     }
 
     fn check_reference_from_covering_node(&mut self, covering_node: &CoveringNode<'_>) {
-        let offset = covering_node.node().start();
-        if let Some(goto_target) =
-            GotoTarget::from_covering_node(self.model, covering_node, offset, self.tokens)
-        {
-            if let Some(current_definitions) = goto_target
-                .get_definition_targets(self.model, self.mode.to_import_alias_resolution())
-                .and_then(|definitions| definitions.declaration_targets(self.model.db()))
-            {
-                if navigation_targets_intersect(self.target_definitions, &current_definitions) {
-                    let target = ReferenceTarget::new(
-                        self.model.file(),
-                        covering_node.node().range(),
-                        ReferenceKind::Other,
-                    );
-                    self.references.push(target);
-                }
-            }
+        if covering_node_matches_target_definitions(
+            self.model,
+            self.tokens,
+            self.mode,
+            self.target_definitions,
+            covering_node,
+        ) {
+            let target = ReferenceTarget::new(
+                self.model.file(),
+                covering_node.node().range(),
+                ReferenceKind::Other,
+            );
+            self.references.push(target);
         }
     }
 }