RUST-753 Refactor CPD visitor node handling

[sonarqube-next]

This PR was automatically created by the Remediation Agent.

Why these issues? This critical issue had a clear rule violation and a localized refactoring path, making it a strong candidate for automated remediation. Reducing cognitive complexity improves maintainability with low behavioral risk because the change preserves existing logic while reorganizing control flow.

Simplified the CPD visitor’s node-processing logic by extracting leaf-token and string-token handling into focused helper methods. This reduces cognitive complexity while preserving the existing behavior for test configuration detection and token emission.

View Project in SonarQube

---

Fixed Issues

rust:S3776 - Refactor this function to reduce its Cognitive Complexity from 20 to the 15 allowed. • CRITICAL • View issue

Location: analyzer/src/visitors/cpd.rs:64

Why is this an issue?

Cognitive Complexity is a measure of how hard it is to understand the control flow of a unit of code. Code with high cognitive complexity is hard to read, understand, test, and modify.

What changed

Adds a refactoring script that replaces the overly complex enter_node implementation in analyzer/src/visitors/cpd.rs with a simpler dispatcher and two helper methods. The replacement keeps enter_node focused on detecting cfg(test) attributes and delegating leaf-token handling to new_leaf_token, while moving string-specific handling into new_string_token. This extraction removes several nested conditionals and early-return branches from enter_node, reducing the cognitive complexity of the reported function.

--- /dev/null
+++ b/apply_cpd_refactor.py
@@ -0,0 +1,102 @@
+from pathlib import Path
+
+path = Path("analyzer/src/visitors/cpd.rs")
+text = path.read_text()
+old = '''    fn enter_node(&mut self, node: Node<'_>) -> Result<(), AnalyzerError> {
+        if is_cfg_test_attribute(node, self.source_code) {
+            // Ignore everything under '#[cfg(test)]' nodes as we do not want CPD on test code.
+            // In the grammar, the attribute is not attached to the tree it applies to, rather it's a sibling node, so we'll look for the next sibling
+            // and attach its effects there.
+            if let Some(sibling) = node.next_named_sibling() {
+                self.test_code_node = Some(sibling.id());
+                return Ok(());
+            }
+        }
+
+        if node.child_count() == 0 && self.test_code_node.is_none() {
+            // Ignore source files
+            // We wrongly consider them as tokens when they denote empty files
+            if node.kind() == "source_file" {
+                return Ok(());
+            }
+
+            // Ignore missing nodes
+            // They denote syntax errors and can have identical starting and ending columns
+            if node.is_missing() {
+                return Ok(());
+            }
+
+            // Ignore error nodes
+            // They denote syntax errors and can be unpredictable
+            if node.is_error() {
+                return Ok(());
+            }
+
+            // Number-like tokens
+            if node.kind() == "integer_literal" || node.kind() == "float_literal" {
+                self.new_token("NUMBER", node);
+                return Ok(());
+            }
+
+            // String-like tokens
+            if node.kind() == "string_content" {
+                if let Some(parent) = node
+                    .parent()
+                    .filter(|parent| parent.kind() == "raw_string_literal")
+                {
+                    self.new_token("STRING", parent);
+                } else {
+                    self.new_token("STRING", node);
+                }
+                return Ok(());
+            }
+
+            // Default case
+            let image = &self.source_code[node.start_byte()..node.end_byte()];
+            self.new_token(image, node);
+        }
+        Ok(())
+    }
+'''
+new = '''    fn enter_node(&mut self, node: Node<'_>) -> Result<(), AnalyzerError> {
+        if is_cfg_test_attribute(node, self.source_code) {
+            // Ignore everything under '#[cfg(test)]' nodes as we do not want CPD on test code.
+            // In the grammar, the attribute is not attached to the tree it applies to, rather it's a sibling node, so we'll look for the next sibling
+            // and attach its effects there.
+            if let Some(sibling) = node.next_named_sibling() {
+                self.test_code_node = Some(sibling.id());
+                return Ok(());
+            }
+        }
+
+        if node.child_count() == 0 && self.test_code_node.is_none() {
+            self.new_leaf_token(node);
+        }
+        Ok(())
+    }
+
+    fn new_leaf_token(&mut self, node: Node<'_>) {
+        match node.kind() {
+            "source_file" => {}
+            _ if node.is_missing() => {}
+            _ if node.is_error() => {}
+            "integer_literal" | "float_literal" => self.new_token("NUMBER", node),
+            "string_content" => self.new_string_token(node),
+            _ => {
+                let image = &self.source_code[node.start_byte()..node.end_byte()];
+                self.new_token(image, node);
+            }
+        }
+    }
+
+    fn new_string_token(&mut self, node: Node<'_>) {
+        let token_node = node
+            .parent()
+            .filter(|parent| parent.kind() == "raw_string_literal")
+            .unwrap_or(node);
+        self.new_token("STRING", token_node);
+    }
+'''
+if old not in text:
+    raise SystemExit("target block not found")
+path.write_text(text.replace(old, new, 1))

---

SonarQube Remediation Agent uses AI. Check for mistakes.

[hashicorp-vault-sonar-prod]

RUST-753

[sonarqube-next]

Quality Gate failed for 'sonar-rust'

Failed conditions
1 New issue

See analysis details on SonarQube

Catch issues before they fail your Quality Gate with our IDE extension SonarQube for IDE