sonicop 26.8.112 → 26.8.113

data/src/rules/layout/heredoc_argument_closing_parenthesis.rs

@@ -10,6 +10,7 @@ use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 use crate::rules::send_node::{Argument, arguments, heredoc_body, is_plain_send};
+use crate::rules::send_node::named_children_iter;
 
 const MSG: &str = "Put the closing parenthesis for a method call with a HEREDOC parameter on the \
                    same line as the HEREDOC opening.";
@@ -73,7 +74,7 @@ fn extract_heredoc_argument<'tree>(
 }
 
 /// `extract_heredoc`: the heredoc a value is, opens a chain with, or holds under a hash key.
-fn extract_heredoc<'tree>(node: Node<'tree>, context: &RuleContext<'_>) -> Option<Node<'tree>> {
+fn extract_heredoc<'tree>(node: Node<'tree>, context: &'tree RuleContext<'_>) -> Option<Node<'tree>> {
     if node.kind_str() == "heredoc_beginning" {
         return Some(node);
     }
@@ -84,8 +85,8 @@ fn extract_heredoc<'tree>(node: Node<'tree>, context: &RuleContext<'_>) -> Optio
     // the brace-less form, whose `hash` upstream builds and the grammar does not.
     let values: Vec<Node<'tree>> = match node.kind_str() {
         "hash" => {
-            let mut cursor = node.walk();
-            node.named_children(&mut cursor)
+            let _cursor = node.walk();
+            named_children_iter(node, context)
                 .filter(|child| child.kind_str() == "pair")
                 .filter_map(|pair| pair.field("value"))
                 .collect()
@@ -357,8 +358,8 @@ fn heredoc_terminator(node: Node<'_>, context: &RuleContext<'_>) -> Option<Range
         return None;
     }
     let body = heredoc_body(node, context)?;
-    let mut cursor = body.walk();
-    body.named_children(&mut cursor)
+    let _cursor = body.walk();
+    named_children_iter(body, context)
         .find(|child| child.kind_str() == "heredoc_end")
         .map(|child| child.byte_range())
 }

data/src/rules/layout/heredoc_indentation.rs

@@ -8,6 +8,7 @@ use crate::diagnostic::{Edit, Offense};
 use crate::ruby_version::RubyVersion;
 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>) {
     // `minimum_target_ruby_version 2.3`: `<<~` is what the cop asks for, and it did not exist
@@ -101,9 +102,9 @@ fn heredocs<'ctx, 'tree>(
         .enumerate()
         .filter_map(|(index, node)| {
             let opener = *openers.get(index)?;
-            let mut cursor = node.walk();
-            let end = node
-                .named_children(&mut cursor)
+            let _cursor = node.walk();
+            let end = named_children_of(node, context)
+                .into_iter()
                 .find(|child| child.kind_str() == "heredoc_end")?;
             let first_body_line = context.source.line_column(node.start_byte()).0 + 1;
             let terminator_line = context.source.line_column(end.start_byte()).0;

data/src/rules/layout/indentation_style.rs

@@ -5,6 +5,7 @@ use std::ops::Range;
 use crate::diagnostic::{Edit, 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 tabs = context
@@ -77,11 +78,11 @@ fn string_literals(context: &RuleContext<'_>) -> Vec<Range<usize>> {
         .map(|node| node.byte_range())
         .collect();
     for body in context.nodes_of("heredoc_body") {
-        let mut cursor = body.walk();
+        let _cursor = body.walk();
         // `loc.heredoc_body` stops at the start of the terminator's *line*, so the indentation a
         // squiggly heredoc's terminator was written with is code as far as this cop is concerned.
-        let end = body
-            .named_children(&mut cursor)
+        let end = named_children_of(body, context)
+            .into_iter()
             .find(|child| child.kind_str() == "heredoc_end")
             .map_or_else(
                 || body.end_byte(),

data/src/rules/layout/indentation_width.rs

@@ -11,7 +11,9 @@ use super::support::{
 };
 use crate::diagnostic::Offense;
 use crate::rules::node_ext::NodeExt;
-use crate::rules::{RuleContext, push_named_children};
+use crate::rules::{RuleContext, push_named_children_in};
+use crate::rules::send_node::named_children_of;
+use crate::rules::send_node::all_children_of;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let width: i64 = context
@@ -48,7 +50,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let mut stack = vec![context.root_node()];
     while let Some(node) = stack.pop() {
         checker.visit(node, offenses);
-        push_named_children(node, &mut stack);
+        push_named_children_in(node, context, &mut stack);
     }
 }
 
@@ -203,9 +205,9 @@ impl Checker<'_, '_> {
         };
         let row = |byte: usize| self.context.source.line_column(byte).0;
         // `dot_on_new_line?`: the receiver stops on an earlier line than the dot.
-        let mut cursor = call.walk();
-        let dot = call
-            .children(&mut cursor)
+        let _cursor = call.walk();
+        let dot = all_children_of(call, self.context)
+            .into_iter()
             .find(|child| !child.is_named() && matches!(child.kind_str(), "." | "&."));
         if let Some(dot) = dot
             && call
@@ -281,9 +283,9 @@ impl Checker<'_, '_> {
     }
 
     fn on_case(&mut self, node: Node<'_>, branch_kind: &str, offenses: &mut Vec<Offense>) {
-        let mut cursor = node.walk();
-        let branches: Vec<Node<'_>> = node
-            .named_children(&mut cursor)
+        let _cursor = node.walk();
+        let branches: Vec<Node<'_>> = named_children_of(node, self.context)
+            .into_iter()
             .filter(|child| child.kind_str() == branch_kind)
             .collect();
         let mut last_keyword = None;
@@ -345,9 +347,9 @@ impl Checker<'_, '_> {
         if node.field("receiver").is_some() {
             return;
         }
-        let mut cursor = node.walk();
-        let Some(list) = node
-            .children(&mut cursor)
+        let _cursor = node.walk();
+        let Some(list) = all_children_of(node, self.context)
+            .into_iter()
             .find(|child| child.kind_str() == "argument_list")
         else {
             return;
@@ -694,8 +696,7 @@ fn is_statement_container(node: Node<'_>) -> bool {
 
 fn body_container<'tree>(owner: Node<'tree>) -> Option<Node<'tree>> {
     let mut cursor = owner.walk();
-    owner
-        .named_children(&mut cursor)
+    owner.named_children(&mut cursor)
         .find(|child| matches!(child.kind_str(), "body_statement" | "block_body" | "do"))
 }
 

data/src/rules/layout/line_continuation_leading_space.rs

@@ -6,7 +6,8 @@ use tree_sitter::Node;
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
-use crate::rules::send_node::named_children;
+use crate::rules::send_node::named_children_of;
+use crate::rules::send_node::named_children_iter;
 
 /// Ruby's `\s`, which stays ASCII where this engine's would take in every Unicode blank.
 const BLANK: &str = r"[ \t\r\n\x0B\x0C]";
@@ -130,7 +131,7 @@ fn is_continuation(one: &str, line: usize, node: Node<'_>, context: &RuleContext
     if !one.ends_with("\\\n") {
         return false;
     }
-    named_children(node).into_iter().all(|child| {
+    named_children_iter(node, context).all(|child| {
         let first = context.source.line_column(child.start_byte()).0;
         let last = context.source.line_column(child.end_byte()).0;
         !((first..last).contains(&line) && first != last)
@@ -145,7 +146,7 @@ fn is_dynamic_string(node: Node<'_>, context: &RuleContext<'_>) -> bool {
         return true;
     }
     context.source.line_column(node.start_byte()).0 != context.source.line_column(node.end_byte()).0
-        || named_children(node)
+        || named_children_of(node, context)
             .iter()
             .any(|child| child.kind_str() == "interpolation")
 }

data/src/rules/layout/line_continuation_spacing.rs

@@ -3,9 +3,9 @@ use std::ops::Range;
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
-use crate::rules::send_node::named_children;
 
 use super::tokens::tokens;
+use crate::rules::send_node::named_children_of;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     if !context.source.text().contains('\\') {
@@ -118,7 +118,7 @@ fn ignored_ranges(context: &RuleContext<'_>) -> Vec<Range<usize>> {
     // interpolations one `str` node, where the grammar splits it at every escape.
     for literal in context.nodes_of_any(&["regex", "subshell"]) {
         let mut run: Option<Range<usize>> = None;
-        for child in named_children(literal) {
+        for child in named_children_of(literal, context) {
             match child.kind_str() == "interpolation" {
                 true => ranges.extend(run.take()),
                 false => {

data/src/rules/layout/line_length.rs

@@ -10,6 +10,7 @@ use crate::rules::node_ext::NodeExt;
 use crate::rules::support::Interpolations;
 use crate::rules::support::is_ruby_space_char;
 use crate::source::is_protected;
+use crate::rules::send_node::named_children_iter;
 
 /// `Layout/IndentationStyle`'s `IndentationWidth` is unset by default, so RuboCop falls back to
 /// `Layout/IndentationWidth`'s `Width`, which is 2. A cop only ever sees its own configuration
@@ -35,16 +36,6 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         true => rbs_annotation_lines(context),
         false => HashSet::new(),
     };
-    let allow_uri: bool = context.setting("AllowURI").unwrap_or(true);
-    let allow_qualified_name: bool = context.setting("AllowQualifiedName").unwrap_or(true);
-    // `allowed_line?`: a line matching one of these is never long, whatever it holds.
-    let allowed_patterns =
-        crate::rules::naming::support::forbidden_patterns_named(context, "AllowedPatterns");
-    let uri_pattern = match context.setting::<Vec<String>>("URISchemes") {
-        Some(schemes) if !schemes.is_empty() => uri_regex(&schemes),
-        _ => URI.clone(),
-    };
-
     // RuboCop drops the `__END__` line and the data section behind it from the lines it walks, so
     // a long line down there is not a long line of code.
     let data_line = context
@@ -53,26 +44,39 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         .map_or(usize::MAX, |node| node.start_position().row + 1);
     let last_line = context.source.line_count().min(data_line.saturating_sub(1));
 
-    // Building autocorrections walks a large part of the AST. Most files have no line over the
-    // limit, so first answer the one condition under which any of that work can be observed.
-    let has_candidate = (1..=last_line).any(|line_number| {
-        let raw = context.source.line(line_number);
-        let line = crate::rules::support::chomp(raw);
-        let length = line.chars().count() + indentation_difference(line);
-        length > max
-            && !(line_number == 1 && line.starts_with("#!"))
-            && !rbs_lines.contains(&line_number)
-            && !(context.in_heredoc(
-                context.source.line_start(line_number)
-                    ..context.source.line_start(line_number) + line.len(),
-            ) && (allow_all_heredocs || allowed_heredoc_lines.contains(&line_number)))
-    });
-    if !has_candidate {
+    // Building autocorrections walks a large part of the AST, and every break it finds is filed
+    // under a line. Only the lines that are over the limit are ever looked up again, so the lines
+    // are settled first and the walk below is held to them. Most files have none at all.
+    let candidate_lines: HashSet<usize> = (1..=last_line)
+        .filter(|line_number| {
+            let raw = context.source.line(*line_number);
+            let line = crate::rules::support::chomp(raw);
+            let length = line.chars().count() + indentation_difference(line);
+            length > max
+                && !(*line_number == 1 && line.starts_with("#!"))
+                && !rbs_lines.contains(line_number)
+                && !(context.in_heredoc(
+                    context.source.line_start(*line_number)
+                        ..context.source.line_start(*line_number) + line.len(),
+                ) && (allow_all_heredocs || allowed_heredoc_lines.contains(line_number)))
+        })
+        .collect();
+    if candidate_lines.is_empty() {
         return;
     }
 
+    let allow_uri: bool = context.setting("AllowURI").unwrap_or(true);
+    let allow_qualified_name: bool = context.setting("AllowQualifiedName").unwrap_or(true);
+    // `allowed_line?`: a line matching one of these is never long, whatever it holds.
+    let allowed_patterns =
+        crate::rules::naming::support::forbidden_patterns_named(context, "AllowedPatterns");
+    let uri_pattern = match context.setting::<Vec<String>>("URISchemes") {
+        Some(schemes) if !schemes.is_empty() => uri_regex(&schemes),
+        _ => &*URI,
+    };
+
     let allow_directives = allow_cop_directives(context);
-    let break_edits = line_break_edits(context, max);
+    let break_edits = line_break_edits(context, max, &candidate_lines);
     let directive_lines = directive_lines(context);
     let endless_method_lines = endless_method_lines(context);
 
@@ -122,10 +126,10 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             (max, without)
         } else if allow_uri || allow_qualified_name {
             let uri = allow_uri
-                .then(|| excessive_range(line, MatchKind::Uri, max, indent, &uri_pattern))
+                .then(|| excessive_range(line, MatchKind::Uri, max, indent, uri_pattern))
                 .flatten();
             let name = allow_qualified_name
-                .then(|| excessive_range(line, MatchKind::QualifiedName, max, indent, &uri_pattern))
+                .then(|| excessive_range(line, MatchKind::QualifiedName, max, indent, uri_pattern))
                 .flatten();
             if exempted(uri, name, length, max) {
                 continue;
@@ -332,8 +336,7 @@ fn name_start(node: Node<'_>, object: Node<'_>) -> usize {
 
 fn is_endless_method(node: Node<'_>) -> bool {
     let mut cursor = node.walk();
-    !node
-        .children(&mut cursor)
+    !node.children(&mut cursor)
         .any(|child| child.kind_str() == "end")
 }
 
@@ -451,14 +454,23 @@ static QUALIFIED_NAME: LazyLock<Regex> = LazyLock::new(|| {
 /// a `//` and the negative lookahead was only ever reachable without one.
 /// `URISchemes`: the schemes `URI::DEFAULT_PARSER.make_regexp` is built from. Hard-coding
 /// `https?` made a line holding any other scheme -- the config exists to name one -- too long.
-fn uri_regex(schemes: &[String]) -> Regex {
+/// The pattern is built from the configuration, so it cannot live in a `LazyLock` -- but the
+/// configuration does not change between files, and `URISchemes` is set in the default
+/// configuration, so this was compiling the RFC 2396 grammar once per file. It was the single
+/// largest cop cost in a run over RuboCop's own tree.
+fn uri_regex(schemes: &[String]) -> &'static Regex {
     let escaped: Vec<String> = schemes.iter().map(|scheme| regex::escape(scheme)).collect();
-    build_uri_regex(&escaped.join("|"))
+    crate::rules::regex_cache::compiled(&uri_regex_pattern(&escaped.join("|")))
+        .unwrap_or_else(|| &URI)
 }
 
 static URI: LazyLock<Regex> = LazyLock::new(|| build_uri_regex("https?"));
 
 fn build_uri_regex(schemes: &str) -> Regex {
+    Regex::new(&uri_regex_pattern(schemes)).unwrap()
+}
+
+fn uri_regex_pattern(schemes: &str) -> String {
     const ESCAPED: &str = r"%[a-fA-F\d]{2}";
     let uric_no_slash = format!(r"(?:[\-_.!~*'()a-zA-Z\d;?:@&=+$,]|{ESCAPED})");
     let uric = format!(r"(?:[\-_.!~*'()a-zA-Z\d;/?:@&=+$,\[\]]|{ESCAPED})");
@@ -470,10 +482,9 @@ fn build_uri_regex(schemes: &str) -> Regex {
     let pchar = format!(r"(?:[\-_.!~*'()a-zA-Z\d:@&=+$,]|{ESCAPED})");
     let segment = format!(r"{pchar}*(?:;{pchar}*)*");
     let abs_path = format!(r"/{segment}(?:/{segment})*");
-    Regex::new(&format!(
+    format!(
         r"(?:{schemes}):(?:{uric_no_slash}{uric}*|(?:(?://(?:(?:(?:{userinfo}@)?(?:{host}(?::(?-u:\d)*)?))?|{reg_name}))?(?:{abs_path})?)(?:\?{uric}*)?)(?:\#{uric}*)?"
-    ))
-    .unwrap()
+    )
 }
 
 /// Whether `URI.parse` accepts the string, which RuboCop uses to weed out RFC 2396 matches that
@@ -579,6 +590,7 @@ fn visit_order(node: Node<'_>, order: &HashMap<usize, u32>) -> (u32, u8) {
 fn line_break_edits(
     context: &RuleContext<'_>,
     max: usize,
+    lines: &HashSet<usize>,
 ) -> HashMap<usize, (Edit, std::ops::Range<usize>)> {
     let breaker = Breaker {
         context,
@@ -599,10 +611,10 @@ fn line_break_edits(
     // Reversed, so that the first semicolon on a line is the one whose position survives.
     if context.source.text().contains(';') {
         for offset in semicolon_break_positions(context).into_iter().rev() {
-            positions.insert(
-                context.source.line_column(offset).0,
-                (offset..(offset + 1), "\n".to_owned()),
-            );
+            let line = context.source.line_column(offset).0;
+            if lines.contains(&line) {
+                positions.insert(line, (offset..(offset + 1), "\n".to_owned()));
+            }
         }
     }
 
@@ -611,6 +623,9 @@ fn line_break_edits(
     // element a break would otherwise go in front of.
     if context.setting::<bool>("SplitStrings").unwrap_or(false) {
         for node in context.nodes_of_any(&["string", "bare_string"]) {
+            if !lines.contains(&(node.start_position().row + 1)) {
+                continue;
+            }
             let Some((offset, delimiter)) = breakable_string(context, node, max) else {
                 continue;
             };
@@ -626,28 +641,58 @@ fn line_break_edits(
         }
     }
 
+    // A break is filed under the line of a node the break goes in front of, which lies inside
+    // `node` -- except for a block, whose break is filed under the line the call it hangs off
+    // begins on, and that call can start earlier. A node spanning no over-long line has nothing to
+    // contribute, and finding that out costs two integers rather than a search for the element.
+    let mut candidates: Vec<Node<'_>> = context
+        .nodes_of_any(BREAKABLE_KINDS)
+        .filter(|node| {
+            let first = match matches!(node.kind_str(), "block" | "do_block") {
+                true => node
+                    .parent_of(context)
+                    .unwrap_or(*node)
+                    .start_position()
+                    .row,
+                false => node.start_position().row,
+            };
+            (first + 1..=node.end_position().row + 1).any(|line| lines.contains(&line))
+        })
+        .collect();
+    if candidates.is_empty() {
+        return finish(positions);
+    }
     let order = upstream_order(context.root_node());
-    let mut candidates: Vec<Node<'_>> = context.nodes_of_any(BREAKABLE_KINDS).collect();
     candidates.sort_by_key(|node| visit_order(*node, &order));
 
     for node in candidates {
         if matches!(node.kind_str(), "block" | "do_block") {
-            if let Some(offset) = breaker.block_break_position(node) {
-                // Upstream's block node starts at the receiver, not at the brace, so a call split
-                // over two lines files its break under the line the receiver is on.
-                let owner = node.parent_of(context).unwrap_or(node);
-                positions.insert(
-                    owner.start_position().row + 1,
-                    (offset..(offset + 1), "\n".to_owned()),
-                );
+            // Upstream's block node starts at the receiver, not at the brace, so a call split
+            // over two lines files its break under the line the receiver is on.
+            let owner = node.parent_of(context).unwrap_or(node);
+            let line = owner.start_position().row + 1;
+            if lines.contains(&line)
+                && let Some(offset) = breaker.block_break_position(node)
+            {
+                positions.insert(line, (offset..(offset + 1), "\n".to_owned()));
             }
         } else if let Some(element) = breaker.breakable_element(node) {
-            positions
-                .entry(element.start_position().row + 1)
-                .or_insert_with(|| (element.byte_range(), "\n".to_owned()));
+            let line = element.start_position().row + 1;
+            if lines.contains(&line) {
+                positions
+                    .entry(line)
+                    .or_insert_with(|| (element.byte_range(), "\n".to_owned()));
+            }
         }
     }
 
+    finish(positions)
+}
+
+/// Turns each recorded break into the insertion it stands for.
+fn finish(
+    positions: HashMap<usize, (std::ops::Range<usize>, String)>,
+) -> HashMap<usize, (Edit, std::ops::Range<usize>)> {
     positions
         .into_iter()
         .map(|(line, (anchor, replacement))| {
@@ -791,8 +836,7 @@ impl Breaker<'_, '_> {
         let mut cursor = container.walk();
         // A comment is a node of the tree but not of RuboCop's AST, and a heredoc's body hangs off
         // the argument list it was opened in rather than off the opener, so neither is an element.
-        let children: Vec<Node<'t>> = container
-            .named_children(&mut cursor)
+        let children: Vec<Node<'t>> = container.named_children(&mut cursor)
             .filter(|child| !matches!(child.kind_str(), "comment" | "heredoc_body"))
             .collect();
         // A literal hash's own pairs are its elements; only an argument list and an array literal
@@ -1200,8 +1244,8 @@ fn breakable_dstr(
     max: usize,
     delimiter: &'static str,
 ) -> Option<(usize, &'static str)> {
-    let mut cursor = node.walk();
-    for child in node.named_children(&mut cursor) {
+    let _cursor = node.walk();
+    for child in named_children_iter(node, context) {
         if child.kind_str() != "interpolation" {
             continue;
         }
@@ -1227,8 +1271,8 @@ fn breakable_string_part(
     delimiter: &'static str,
 ) -> Option<(usize, &'static str)> {
     let parent_column = context.source.line_column(node.start_byte()).1 - 1;
-    let mut cursor = node.walk();
-    for part in node.named_children(&mut cursor) {
+    let _cursor = node.walk();
+    for part in named_children_iter(node, context) {
         if part.kind_str() != "string_content" {
             continue;
         }

data/src/rules/layout/multiline_assignment_layout.rs

@@ -5,6 +5,7 @@ use crate::rules::RuleContext;
 use crate::rules::lint::blocks::BlockArgs;
 use crate::rules::lint::locals::LocalVariables;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::all_children_iter;
 
 const NEW_LINE_OFFENSE: &str = "Right hand side of multi-line assignment is on the same line as \
                                 the assignment operator `=`.";
@@ -157,10 +158,10 @@ fn block_of(
 }
 
 /// `node.loc.operator`: the `=` or `+=` the assignment was written with.
-fn operator<'tree>(node: Node<'tree>, context: &RuleContext<'_>) -> Option<Node<'tree>> {
+fn operator<'tree>(node: Node<'tree>, context: &'tree RuleContext<'_>) -> Option<Node<'tree>> {
     let left = node.field("left")?;
-    let mut cursor = node.walk();
-    node.children(&mut cursor)
+    let _cursor = node.walk();
+    all_children_iter(node, context)
         .filter(|child| !child.is_named() && child.start_byte() >= left.end_byte())
         .find(|child| context.source.node_text(*child).ends_with('='))
 }

data/src/rules/layout/multiline_block_layout.rs

@@ -131,8 +131,7 @@ fn argument_string(context: &RuleContext<'_>, arguments: Node<'_>) -> String {
 
 fn parameter_nodes<'tree>(arguments: Node<'tree>) -> Vec<Node<'tree>> {
     let mut cursor = arguments.walk();
-    arguments
-        .named_children(&mut cursor)
+    arguments.named_children(&mut cursor)
         .filter(|child| !matches!(child.kind_str(), "comment" | "heredoc_body"))
         .collect()
 }