sonicop 26.8.112 → 26.8.113

data/src/rules/metrics/fragments.rs

@@ -10,22 +10,22 @@
 //! copy of the file with every other byte blanked out -- so its nodes carry the offsets they were
 //! written at and can be read against the original source like any others.
 
-use std::collections::HashSet;
 use std::ops::Range;
 
-use tree_sitter::{Node, Parser, Tree};
+use tree_sitter::{Node, Tree};
 
 use super::locals::named_children;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_iter;
 
 pub(in crate::rules) struct Fragments {
     /// The recovered parse, absent when the file holds nothing to recover.
     tree: Option<Tree>,
     /// The nodes whose text was swallowed, by node id.
-    hosts: HashSet<usize>,
+    hosts: crate::rules::IdSet,
     /// Of those, the ones standing for a `%` applied to the string before them.
-    operators: HashSet<usize>,
+    operators: crate::rules::IdSet,
 }
 
 impl Fragments {
@@ -43,7 +43,7 @@ impl Fragments {
             .collect();
         let percents: Vec<Node<'_>> = context
             .nodes_of("chained_string")
-            .flat_map(|chained| named_children(chained).into_iter().skip(1))
+            .flat_map(|chained| named_children_iter(chained, context).skip(1))
             .filter(|part| {
                 part.kind_str() == "string" && source[part.byte_range()].starts_with('%')
             })
@@ -51,13 +51,13 @@ impl Fragments {
         if comments.is_empty() && percents.is_empty() {
             return Self {
                 tree: None,
-                hosts: HashSet::new(),
-                operators: HashSet::new(),
+                hosts: crate::rules::IdSet::default(),
+                operators: crate::rules::IdSet::default(),
             };
         }
 
-        let mut hosts = HashSet::new();
-        let mut operators = HashSet::new();
+        let mut hosts = crate::rules::IdSet::default();
+        let mut operators = crate::rules::IdSet::default();
         let mut blanked = Blanked::new(source);
         for comment in comments {
             if blanked.write_interpolations(comment.byte_range()) {
@@ -175,11 +175,7 @@ impl<'a> Blanked<'a> {
             return None;
         }
         let text = String::from_utf8(self.bytes).ok()?;
-        let mut parser = Parser::new();
-        parser
-            .set_language(&tree_sitter_ruby::LANGUAGE.into())
-            .ok()?;
-        parser.parse(&text, None)
+        crate::parser::parse(&text)
     }
 }
 

data/src/rules/metrics/locals.rs

@@ -22,16 +22,17 @@ use crate::rules::support::{scope_kind, spurious_assignment_list};
 use crate::source::SourceFile;
 
 pub(in crate::rules) struct Locals {
-    lvars: HashSet<usize>,
+    lvars: crate::rules::IdSet,
 }
 
 impl Locals {
     pub(in crate::rules) fn new(context: &RuleContext<'_>, fragments: &Fragments) -> Self {
         let mut walker = Walker {
             source: context.source,
+            index: context.ast_index(),
             fragments,
             stack: vec![Frame::new(false)],
-            lvars: HashSet::new(),
+            lvars: crate::rules::IdSet::default(),
         };
         walker.visit(context.root_node());
         Self {
@@ -63,9 +64,12 @@ impl Frame<'_> {
 
 struct Walker<'a> {
     source: &'a SourceFile,
+    /// The file's node index: `is_variable_read` asks for a parent on every identifier, and
+    /// `Node::parent` walks down from the root each time.
+    index: &'a super::super::AstIndex<'a>,
     fragments: &'a Fragments,
     stack: Vec<Frame<'a>>,
-    lvars: HashSet<usize>,
+    lvars: crate::rules::IdSet,
 }
 
 impl<'a> Walker<'a> {
@@ -330,7 +334,7 @@ impl<'a> Walker<'a> {
     }
 
     fn visit_identifier(&mut self, node: Node<'_>) {
-        if !is_variable_read(node) {
+        if !is_variable_read(node, self.index) {
             return;
         }
         if self.declared(self.text(node)) {
@@ -489,7 +493,14 @@ pub(super) fn named_children<'tree>(node: Node<'tree>) -> Vec<Node<'tree>> {
     node.named_children(&mut cursor).collect()
 }
 
-pub(super) fn field_name(child: Node<'_>, parent: Node<'_>) -> Option<&'static str> {
+pub(super) fn field_name(
+    child: Node<'_>,
+    parent: Node<'_>,
+    index: &super::super::AstIndex<'_>,
+) -> Option<&'static str> {
+    if index.knows(child) {
+        return index.field_name_of(child);
+    }
     let mut cursor = parent.walk();
     if !cursor.goto_first_child() {
         return None;
@@ -531,14 +542,14 @@ pub(super) fn folded_parameter_list<'tree>(value: Node<'tree>) -> Option<Node<'t
 
 /// Whether an identifier stands where the parser upstream would have built an `lvar`, rather than
 /// a name being declared, written or called.
-fn is_variable_read(node: Node<'_>) -> bool {
-    let Some(parent) = node.parent() else {
+fn is_variable_read(node: Node<'_>, index: &super::super::AstIndex<'_>) -> bool {
+    let Some(parent) = index.parent(node) else {
         return true;
     };
     match parent.kind_str() {
-        "call" => field_name(node, parent) != Some("method"),
-        "method" | "singleton_method" => field_name(node, parent) != Some("name"),
-        "assignment" | "operator_assignment" => field_name(node, parent) != Some("left"),
+        "call" => field_name(node, parent, index) != Some("method"),
+        "method" | "singleton_method" => field_name(node, parent, index) != Some("name"),
+        "assignment" | "operator_assignment" => field_name(node, parent, index) != Some("left"),
         "left_assignment_list"
         | "rest_assignment"
         | "destructured_left_assignment"
@@ -554,8 +565,8 @@ fn is_variable_read(node: Node<'_>) -> bool {
         | "keyword_parameter"
         | "splat_parameter"
         | "hash_splat_parameter"
-        | "block_parameter" => field_name(node, parent) != Some("name"),
-        "for" => field_name(node, parent) != Some("pattern"),
+        | "block_parameter" => field_name(node, parent, index) != Some("name"),
+        "for" => field_name(node, parent, index) != Some("pattern"),
         _ => true,
     }
 }

data/src/rules/metrics/parameter_lists.rs

@@ -4,6 +4,7 @@ use super::support::constructor_call;
 use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let max: usize = context.setting("Max").unwrap_or(5);
@@ -32,9 +33,9 @@ fn report_optional_parameters(
     let count = node
         .field("parameters")
         .map_or(0, |parameters| {
-            let mut cursor = parameters.walk();
-            parameters
-                .named_children(&mut cursor)
+            let _cursor = parameters.walk();
+            named_children_of(parameters, context)
+                .into_iter()
                 .filter(|parameter| parameter.kind_str() == "optional_parameter")
                 .map(folded_parameter_count)
                 .sum()
@@ -60,11 +61,11 @@ fn report_parameter_count(
     if struct_or_data_initialize(context, node) {
         return;
     }
-    let mut cursor = node.walk();
+    let _cursor = node.walk();
     // An explicit block argument is never counted: making it implicit is a rename away, so
     // counting it would push authors toward a change the cop does not actually want.
-    let count: usize = node
-        .named_children(&mut cursor)
+    let count: usize = named_children_of(node, context)
+        .into_iter()
         .filter(|parameter| parameter.kind_str() != "block_parameter")
         .filter(|parameter| count_keywords || parameter.kind_str() != "keyword_parameter")
         .map(folded_parameter_count)

data/src/rules/metrics/support.rs

@@ -234,7 +234,7 @@ fn classlike_code_line_count(
         return 0;
     }
     let mut excluded_lines = HashSet::new();
-    walk_named(node, &mut |descendant| {
+    walk_named(node, context, &mut |descendant| {
         if descendant == node || !matches!(descendant.kind_str(), "class" | "module") {
             return;
         }