sonicop 26.8.106 → 26.8.107

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c90ed3a9d03214ba6922d2aecd35c70b28e09791c870f06c22848ef05b336054
-  data.tar.gz: 0557036a886b2023e5151d8b18b1df8bdd66725faf957d19013412a0bc62c6ef
+  metadata.gz: 5972ef39a175515ffae2b30a2061487cc72c3d3945b58fb0a4277a55ed37517c
+  data.tar.gz: 70853c91d098efd59af3442c50ccee948279c76b77a8b2daa0ba66a34a5a3ca1
 SHA512:
-  metadata.gz: 63191904f82e06d89200c5b81a22a9ad6a4ebcbf07ed86039966605a2d87225d7984a2dfd7a3b0a7b38ca54aaebc1b36518fdb1eeb5dead16318168e3441d692
-  data.tar.gz: deb43652b8dfd0c2c9fac7ed27a1a33fb1097e76bd2d455851ba04d30d2fc6751025fadfdc4012d06f6a45140a983a5686b7bdfc3e5436e5d9ea0e238da26ddd
+  metadata.gz: 0cffd8b515ab79c07087248461158a204d92f47c1b88889c4f1ef14581493cff38c83891ed7cd8eac205db5b177292c9ec7ed2a63b2bf876a9cfd024174c5c26
+  data.tar.gz: f7d324f0b70eb06b5b12a1f905cb23a4fc8b681fa15b2943e2f6946593e95075b70f68f9f150ce994a90a7c35b94ccecac962c555de232a52a92c4d86f0ef99a

data/Cargo.lock

@@ -742,7 +742,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sonicop"
-version = "26.8.106"
+version = "26.8.107"
 dependencies = [
  "anyhow",
  "assert_cmd",

data/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sonicop"
-version = "26.8.106"
+version = "26.8.107"
 edition = "2024"
 rust-version = "1.85"
 description = "A fast, native RuboCop-compatible Ruby linter and formatter"

data/lib/sonicop/version.rb

@@ -2,5 +2,5 @@
 
 # Generated from Cargo.toml by `rake version:sync`. Do not edit by hand.
 module Sonicop
-  VERSION = '26.8.106'
+  VERSION = '26.8.107'
 end

data/src/directives.rs

@@ -334,7 +334,7 @@ fn cop_list(arguments: &str) -> Vec<String> {
 
 /// The length of the cop name `text` starts with, following `COP_NAME_PATTERN`: one or more
 /// `[A-Za-z]\w+` segments separated by slashes.
-fn cop_name_length(text: &str) -> Option<usize> {
+pub(crate) fn cop_name_length(text: &str) -> Option<usize> {
     let bytes = text.as_bytes();
     let mut index = 0;
     loop {
@@ -619,7 +619,7 @@ fn commented_out(prefix: &str) -> bool {
     prefix.starts_with('#')
         && prefix[1..]
             .bytes()
-            .all(|byte| matches!(byte, b' ' | b'\t' | b'\r' | b'\n' | 0x0b | 0x0c))
+            .all(crate::rules::support::is_ruby_space)
 }
 
 /// A `# rubocop:` comment, parsed the way `RuboCop::DirectiveComment` parses one.

data/src/rules/layout/empty_line_after_magic_comment.rs

@@ -1,6 +1,7 @@
 use crate::diagnostic::{Edit, Offense};
 use crate::magic_comment::MagicComment;
 use crate::rules::RuleContext;
+use crate::rules::support;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     // RuboCop takes every comment that precedes the first line of code and keeps the *last* magic
@@ -11,7 +12,16 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         return;
     };
     let next = line_number + 1;
-    if next > context.source.line_count() || context.source.line(next).trim().is_empty() {
+    // `next_line.strip.empty?`. **`str::trim` would also reach over a no-break space**, which
+    // Ruby's `strip` leaves in place: a line holding one is not an empty line, and upstream asks for
+    // a real one to be added under the magic comment.
+    if next > context.source.line_count()
+        || context
+            .source
+            .line(next)
+            .trim_matches(support::is_ruby_strippable)
+            .is_empty()
+    {
         return;
     }
     let insertion = context.source.line_start(next);

data/src/rules/layout/empty_line_after_multiline_condition.rs

@@ -6,6 +6,7 @@ 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::support;
 
 const MSG: &str = "Use empty line after multiline condition.";
 
@@ -139,7 +140,7 @@ fn rescue_branch(node: Node<'_>, context: &RuleContext<'_>) -> Option<Offense> {
 
 /// The offense, whose correction writes a blank line under the last line of `anchor`.
 fn offense(reported: Node<'_>, anchor: Node<'_>, context: &RuleContext<'_>) -> Offense {
-    let lines = whole_lines(anchor.byte_range(), context);
+    let lines = support::whole_lines_without_terminator(anchor.byte_range(), context);
     context
         .offense(MSG, reported.byte_range())
         .corrections_anchored_at(lines.clone())
@@ -184,18 +185,6 @@ fn is_blank(line: usize, context: &RuleContext<'_>) -> bool {
     line > context.source.line_count() || context.source.line(line).trim().is_empty()
 }
 
-/// `range_by_whole_lines(range)`: the lines the node sits on, without the break that closes them.
-fn whole_lines(range: Range<usize>, context: &RuleContext<'_>) -> Range<usize> {
-    let text = context.source.text();
-    let start = text[..range.start]
-        .rfind('\n')
-        .map_or(0, |offset| offset + 1);
-    let end = text[range.end..]
-        .find('\n')
-        .map_or(text.len(), |offset| range.end + offset);
-    start..end
-}
-
 fn line(offset: usize, context: &RuleContext<'_>) -> usize {
     context.source.line_column(offset).0
 }

data/src/rules/layout/empty_lines_after_module_inclusion.rs

@@ -7,6 +7,7 @@ use crate::directives::directive_header;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 use crate::rules::send_node::{arguments, is_plain_send, named_children, send_range};
+use crate::rules::support;
 
 const MSG: &str = "Add an empty line after module inclusion.";
 
@@ -73,7 +74,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         }
         // `autocorrect`: the blank line goes after the inclusion, or after the `rubocop:enable`
         // comment written directly below it.
-        let mut anchor = whole_lines(send_range(node, context), context);
+        let mut anchor = support::whole_lines_without_terminator(send_range(node, context), context);
         let below = context.source.line_column(anchor.end).0 + 1;
         if let Some(comment) = enable_directive_at(below, context) {
             anchor = comment;
@@ -184,14 +185,3 @@ fn enable_directive_at(line: usize, context: &RuleContext<'_>) -> Option<Range<u
     (header.mode == "enable").then(|| comment.clone())
 }
 
-/// `range_by_whole_lines(range)`: the lines the node sits on, without the break that closes them.
-fn whole_lines(range: Range<usize>, context: &RuleContext<'_>) -> Range<usize> {
-    let text = context.source.text();
-    let start = text[..range.start]
-        .rfind('\n')
-        .map_or(0, |offset| offset + 1);
-    let end = text[range.end..]
-        .find('\n')
-        .map_or(text.len(), |offset| range.end + offset);
-    start..end
-}

data/src/rules/layout/line_length.rs

@@ -9,6 +9,7 @@ use crate::rules::RuleContext;
 use crate::rules::support::Interpolations;
 use crate::source::is_protected;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::support::is_ruby_space_char;
 
 /// `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
@@ -117,12 +118,6 @@ fn allow_cop_directives(context: &RuleContext<'_>) -> bool {
     }
 }
 
-/// Ruby's `\s`, which is ASCII-only. Using `char::is_whitespace` here would let a non-breaking
-/// space end a word that RuboCop keeps going through.
-fn is_ruby_space(character: char) -> bool {
-    matches!(character, ' ' | '\t' | '\r' | '\n' | '\u{b}' | '\u{c}')
-}
-
 fn indentation_difference(line: &str) -> usize {
     if !line.starts_with('\t') {
         return 0;
@@ -209,14 +204,14 @@ fn is_endless_method(node: Node<'_>) -> bool {
 fn marker_only(prefix: &str) -> bool {
     prefix
         .strip_prefix('#')
-        .is_some_and(|rest| rest.chars().all(is_ruby_space))
+        .is_some_and(|rest| rest.chars().all(is_ruby_space_char))
 }
 
 fn length_without_directive(line: &str) -> usize {
     DIRECTIVE
         .find(line)
         .map_or(line, |found| &line[..found.start()])
-        .trim_end_matches(is_ruby_space)
+        .trim_end_matches(is_ruby_space_char)
         .chars()
         .count()
 }
@@ -260,8 +255,8 @@ fn extended_end(line: &str, mut end: usize) -> usize {
         }
     }
     let rest = &line[end..];
-    if rest.starts_with(|character| !is_ruby_space(character)) {
-        end += rest.find(is_ruby_space).unwrap_or(rest.len());
+    if rest.starts_with(|character| !is_ruby_space_char(character)) {
+        end += rest.find(is_ruby_space_char).unwrap_or(rest.len());
     }
     end
 }

data/src/rules/layout/multiline_brace.rs

@@ -11,6 +11,7 @@ use tree_sitter::Node;
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::support;
 
 /// The four sentences one of these cops reports with.
 pub(super) struct Messages {
@@ -260,28 +261,12 @@ fn line_end(context: &RuleContext<'_>, offset: usize) -> usize {
 /// `range_with_surrounding_space(range, side: :left)`: the blanks before `offset`, then the line
 /// breaks before those -- and no further, so a blank line above is left alone.
 fn space_before(text: &str, offset: usize) -> usize {
-    let bytes = text.as_bytes();
-    let mut position = offset;
-    while position > 0 && matches!(bytes[position - 1], b' ' | b'\t') {
-        position -= 1;
-    }
-    while position > 0 && bytes[position - 1] == b'\n' {
-        position -= 1;
-    }
-    position
+    support::final_pos(text, offset, false, false, true, false)
 }
 
 /// `range_with_surrounding_space(range, side: :right)`.
 fn space_after(text: &str, offset: usize) -> usize {
-    let bytes = text.as_bytes();
-    let mut position = offset;
-    while position < bytes.len() && matches!(bytes[position], b' ' | b'\t') {
-        position += 1;
-    }
-    while position < bytes.len() && bytes[position] == b'\n' {
-        position += 1;
-    }
-    position
+    support::final_pos(text, offset, true, false, true, false)
 }
 
 /// `Node#chained?`: the node is the receiver of the call written around it.

data/src/rules/layout/space_around_operators.rs

@@ -17,6 +17,8 @@ use crate::diagnostic::{Edit, Offense};
 use crate::ruby_version::RubyVersion;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::support;
+use crate::rules::support::is_ruby_space;
 
 /// The node kinds carrying an operator RuboCop checks. `binary` stands in for `on_send`,
 /// `on_binary`, `on_and` and `on_or`, which all reduce to the same shape in tree-sitter.
@@ -455,22 +457,15 @@ fn check_operator<'src>(
 /// either side, plus the line breaks that follow it. `None` stands for the range that begins
 /// with a line break, which `check_operator` refuses to judge.
 fn surrounding_space(source: &str, operator: &Range<usize>) -> Option<Range<usize>> {
-    let bytes = source.as_bytes();
-    let mut start = operator.start;
-    while start > 0 && matches!(bytes[start - 1], b' ' | b'\t') {
-        start -= 1;
-    }
-    if start > 0 && bytes[start - 1] == b'\n' {
+    // The left side is `range_with_surrounding_space(side: :left, newlines: false)` and the right is
+    // the same with `newlines: true`, **but this cop gives up entirely when a line break sits on the
+    // left**: an operator that opens a line is aligned rather than spaced, so the range is no longer
+    // the thing to measure. That decision belongs to the cop and stays here.
+    let start = support::final_pos(source, operator.start, false, false, false, false);
+    if start > 0 && source.as_bytes()[start - 1] == b'\n' {
         return None;
     }
-    let mut end = operator.end;
-    while end < bytes.len() && matches!(bytes[end], b' ' | b'\t') {
-        end += 1;
-    }
-    while end < bytes.len() && bytes[end] == b'\n' {
-        end += 1;
-    }
-    Some(start..end)
+    Some(start..support::final_pos(source, operator.end, true, false, true, false))
 }
 
 fn should_not_have_surrounding_space(
@@ -533,10 +528,6 @@ fn wrapped_in_space(padded: &str) -> bool {
     false
 }
 
-fn is_ruby_space(byte: u8) -> bool {
-    matches!(byte, b' ' | b'\t' | b'\r' | b'\n' | 0x0b | 0x0c)
-}
-
 fn excess_leading_space(
     settings: &Settings,
     alignment: &Alignment<'_>,

data/src/rules/layout/space_inside_array_percent_literal.rs

@@ -54,7 +54,7 @@ fn unnecessary_spaces(contents: &str) -> Vec<std::ops::Range<usize>> {
         if index - start < 2
             || bytes
                 .get(index)
-                .is_none_or(|byte| byte.is_ascii_whitespace())
+                .is_none_or(|byte| crate::rules::support::separates_words(*byte))
         {
             continue;
         }
@@ -72,5 +72,7 @@ fn word_ends_before(bytes: &[u8], start: usize) -> bool {
     while position >= 2 && bytes[position - 1] == b' ' && bytes[position - 2] == b'\\' {
         position -= 2;
     }
-    position > 0 && !bytes[position - 1].is_ascii_whitespace() && bytes[position - 1] != b'\\'
+    position > 0
+        && !crate::rules::support::separates_words(bytes[position - 1])
+        && bytes[position - 1] != b'\\'
 }

data/src/rules/layout/space_inside_block_braces.rs

@@ -6,6 +6,8 @@ use super::support::{character_column, parser_node_start};
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::support;
+use crate::rules::support::is_ruby_space;
 
 #[derive(Clone, Copy, Eq, PartialEq)]
 enum Style {
@@ -91,7 +93,7 @@ impl Cop<'_, '_> {
             return;
         }
         let inner = &self.text()[left.end_byte()..right.start_byte()];
-        if inner.bytes().any(|byte| !is_space(byte)) {
+        if inner.bytes().any(|byte| !is_ruby_space(byte)) {
             self.braces_with_contents_inside(node, braces, inner, offenses);
         } else if self.empty_style == Style::NoSpace {
             self.offense(
@@ -127,7 +129,7 @@ impl Cop<'_, '_> {
         pipe: Option<Node<'_>>,
         offenses: &mut Vec<Offense>,
     ) {
-        if inner.bytes().next().is_some_and(|byte| !is_space(byte)) {
+        if inner.bytes().next().is_some_and(|byte| !is_ruby_space(byte)) {
             self.no_space_inside_left_brace(left, pipe, offenses);
         } else {
             self.space_inside_left_brace(left, pipe, offenses);
@@ -192,7 +194,7 @@ impl Cop<'_, '_> {
             && inner
                 .bytes()
                 .next_back()
-                .is_some_and(|byte| !is_space(byte))
+                .is_some_and(|byte| !is_ruby_space(byte))
         {
             self.no_space(
                 right.start_byte(),
@@ -263,7 +265,7 @@ impl Cop<'_, '_> {
             return;
         }
         let source = &self.text()[begin_pos..end_pos];
-        let edit = if source.bytes().any(is_space) {
+        let edit = if source.bytes().any(is_ruby_space) {
             Edit {
                 start: begin_pos,
                 end: end_pos,
@@ -330,12 +332,6 @@ fn last_line_spaces(inner: &str) -> i64 {
     })
 }
 
-/// `\s` as Ruby's regexp engine defines it, which is ASCII only -- a non-breaking space is a
-/// character the cop counts as content.
-fn is_space(byte: u8) -> bool {
-    matches!(byte, b' ' | b'\t' | b'\r' | b'\n' | 0x0b | 0x0c)
-}
-
 #[derive(Clone, Copy, Eq, PartialEq)]
 enum Direction {
     Left,
@@ -345,23 +341,14 @@ enum Direction {
 /// `RangeHelp#range_with_surrounding_space` with the defaults this cop passes: the run of spaces
 /// and tabs, and then the run of newlines beyond it.
 fn expand_space(text: &str, offset: usize, direction: Direction) -> usize {
-    let bytes = text.as_bytes();
-    let mut position = offset;
-    let peek = |position: usize| match direction {
-        Direction::Left => (position > 0).then(|| bytes[position - 1]),
-        Direction::Right => bytes.get(position).copied(),
-    };
-    let step = |position: usize| match direction {
-        Direction::Left => position - 1,
-        Direction::Right => position + 1,
-    };
-    while peek(position).is_some_and(|byte| byte == b' ' || byte == b'\t') {
-        position = step(position);
-    }
-    while peek(position).is_some_and(|byte| byte == b'\n') {
-        position = step(position);
-    }
-    position
+    support::final_pos(
+        text,
+        offset,
+        direction == Direction::Right,
+        false,
+        true,
+        false,
+    )
 }
 
 /// Moves `offset` by `delta` characters. Upstream addresses source by character, so a span it

data/src/rules/layout/trailing_empty_lines.rs

@@ -1,5 +1,6 @@
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
+use crate::rules::support;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let text = context.source.text();
@@ -14,7 +15,12 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     // All trailing whitespace, as RuboCop's `/\s*\Z/` takes it -- not just newlines, so a file
     // ending in spaces is measured from where the whitespace starts rather than from the last
     // newline. Only `\n` is counted, leaving carriage returns to `Layout/EndOfLine`.
-    let whitespace_start = text.trim_end_matches(char::is_whitespace).len();
+    // **`char::is_whitespace` would reach over a no-break space**, which `/\s/` does not match:
+    // a last line holding one is not trailing whitespace, and counting it as such reports a blank
+    // line upstream does not see -- and this cop's correction would then delete that line.
+    let whitespace_start = text
+        .trim_end_matches(support::is_ruby_space_char)
+        .len();
     let whitespace = &text[whitespace_start..];
     let blank_lines = whitespace.matches('\n').count() as isize - 1;
     if blank_lines == wanted_blank_lines {

data/src/rules/lint/ambiguous_assignment.rs

@@ -3,8 +3,8 @@ use tree_sitter::Node;
 use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::support::spurious_assignment_list;
 
-use super::variable_force::spurious_assignment_list;
 
 /// `MISTAKES`: the operator each two-character run was probably meant to be.
 const MISTAKES: [(u8, &str); 4] = [(b'-', "-="), (b'+', "+="), (b'*', "*="), (b'!', "!=")];

data/src/rules/lint/comments_help.rs

@@ -0,0 +1,39 @@
+//! `CommentsHelp`: the lines a branch owns, which is where a cop looks for the comment that
+//! excuses an empty one.
+//!
+//! Upstream is one mixin included by both `Lint/EmptyWhen` and `Lint/EmptyInPattern`, so the two
+//! read the same lines for `when` and for `in`.
+
+use std::ops::Range;
+
+use tree_sitter::Node;
+
+use crate::rules::RuleContext;
+use crate::rules::node_ext::NodeExt;
+
+/// `find_end_line`: a `when` runs up to the line the next branch starts on, or to the `end` of the
+/// `case` when it is the last. The range excludes that line, which is why the keyword itself never
+/// counts as a comment of the branch before it.
+pub(super) fn comment_search_lines(
+    context: &RuleContext<'_>,
+    case: Node<'_>,
+    children: &[Node<'_>],
+    index: usize,
+) -> Range<usize> {
+    let branch = children[index];
+    let (start, _) = context.source.line_column(branch.start_byte());
+    let end = children[index + 1..]
+        .iter()
+        .find(|sibling| sibling.kind_str() != "comment")
+        .map_or_else(
+            || {
+                // `parent.loc.end.line`, the `end` keyword closing the `case`.
+                let (line, _) = context
+                    .source
+                    .line_column(case.end_byte().saturating_sub(1));
+                line
+            },
+            |next| context.source.line_column(next.start_byte()).0,
+        );
+    start..end
+}

data/src/rules/lint/constant_reassignment.rs

@@ -6,8 +6,8 @@ use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 use crate::rules::send_node::{arguments, named_children, string_text, symbol_name};
+use crate::rules::support::spurious_assignment_list;
 
-use super::variable_force::spurious_assignment_list;
 
 /// The parts of a constant path, as `each_path` walks them.
 struct ConstantPath {

data/src/rules/lint/cop_directives.rs

@@ -12,6 +12,7 @@
 
 use std::ops::Range;
 
+use crate::directives::cop_name_length;
 use crate::rules::RuleContext;
 
 /// The departments a cop name can be shortened to. `cop_registry.department?` answers from the
@@ -140,29 +141,3 @@ fn next_is_name_character(text: &str, index: usize) -> bool {
         .get(index)
         .is_some_and(|byte| byte.is_ascii_alphanumeric() || *byte == b'_')
 }
-
-/// `COP_NAME_PATTERN`: one or more `[A-Za-z]\w+` segments joined by slashes.
-fn cop_name_length(text: &str) -> Option<usize> {
-    let bytes = text.as_bytes();
-    let mut index = 0;
-    loop {
-        let start = index;
-        if !bytes.get(index).is_some_and(u8::is_ascii_alphabetic) {
-            return None;
-        }
-        index += 1;
-        while bytes
-            .get(index)
-            .is_some_and(|byte| byte.is_ascii_alphanumeric() || *byte == b'_')
-        {
-            index += 1;
-        }
-        if index - start < 2 {
-            return None;
-        }
-        if bytes.get(index) != Some(&b'/') {
-            return Some(index);
-        }
-        index += 1;
-    }
-}

data/src/rules/lint/empty_conditional_body.rs

@@ -132,6 +132,16 @@ fn contains_comments(node: Node<'_>, context: &RuleContext<'_>) -> bool {
     let end = match node.field("alternative") {
         // `find_end_line`: the `else` or `elsif` that follows ends the span.
         Some(clause) => context.source.line_column(clause.start_byte()).0,
+        // `find_end_line`'s `elsif?` branch: `node.each_ancestor(:if).find(&:if?).loc.end.line`.
+        // An `elsif` with nothing after it owns the lines up to the `end` that closes the whole
+        // conditional, and that `end` belongs to the `if` above it. The grammar stops the `elsif`
+        // node at its own last statement, so reading its end instead leaves an empty span and the
+        // comment that excuses the branch is never seen.
+        None if node.kind_str() == "elsif" => enclosing_end(node, context)
+            .map_or_else(
+                || context.source.line_column(node.end_byte()).0,
+                |keyword| context.source.line_column(keyword.start_byte()).0,
+            ),
         None => context.source.line_column(node.end_byte()).0,
     };
     context.comment_ranges().iter().any(|comment| {
@@ -140,6 +150,19 @@ fn contains_comments(node: Node<'_>, context: &RuleContext<'_>) -> bool {
     })
 }
 
+/// The `end` closing the conditional an `elsif` sits in, which is the `if` above it. A chain of
+/// `elsif` nests, so the walk passes any number of them before it reaches the `if`.
+fn enclosing_end<'tree>(node: Node<'tree>, context: &RuleContext<'_>) -> Option<Node<'tree>> {
+    let mut current = node.parent();
+    while let Some(ancestor) = current {
+        if ancestor.kind_str() == "if" {
+            return end_keyword(ancestor, context);
+        }
+        current = ancestor.parent();
+    }
+    None
+}
+
 /// `node.loc.begin`: the `then` or `;` the branch was introduced with. The grammar puts a `then`
 /// inside the branch it opens, but a `;` stays beside the condition -- and a branch holding nothing
 /// is no node at all, which leaves the `;` as the only trace of it.

data/src/rules/lint/empty_in_pattern.rs

@@ -6,6 +6,8 @@ use crate::diagnostic::Offense;
 use crate::directives::DirectiveState;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+
+use super::comments_help::comment_search_lines;
 use crate::ruby_version::RubyVersion;
 
 use super::statements::statements;
@@ -64,31 +66,6 @@ fn allowed_by_comments(
     has_comment && !comments_contain_disables(context, &lines)
 }
 
-/// `find_end_line`: a branch runs up to the line the next one starts on, or to the `end` of the
-/// `case` when it is the last. The range excludes that line.
-fn comment_search_lines(
-    context: &RuleContext<'_>,
-    case: Node<'_>,
-    children: &[Node<'_>],
-    index: usize,
-) -> Range<usize> {
-    let branch = children[index];
-    let (start, _) = context.source.line_column(branch.start_byte());
-    let end = children[index + 1..]
-        .iter()
-        .find(|sibling| sibling.kind_str() != "comment")
-        .map_or_else(
-            || {
-                let (line, _) = context
-                    .source
-                    .line_column(case.end_byte().saturating_sub(1));
-                line
-            },
-            |next| context.source.line_column(next.start_byte()).0,
-        );
-    start..end
-}
-
 fn comments_contain_disables(context: &RuleContext<'_>, lines: &Range<usize>) -> bool {
     let directives = DirectiveState::parse(context.source, context.comment_ranges());
     directives

data/src/rules/lint/empty_when.rs

@@ -7,6 +7,8 @@ use crate::directives::DirectiveState;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 
+use super::comments_help::comment_search_lines;
+
 const MSG: &str = "Avoid `when` branches without a body.";
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
@@ -61,33 +63,6 @@ fn allowed_by_comments(
     has_comment && !comments_contain_disables(context, &lines)
 }
 
-/// `find_end_line`: a `when` runs up to the line the next branch starts on, or to the `end` of the
-/// `case` when it is the last. The range excludes that line, which is why the keyword itself never
-/// counts as a comment of the branch before it.
-fn comment_search_lines(
-    context: &RuleContext<'_>,
-    case: Node<'_>,
-    children: &[Node<'_>],
-    index: usize,
-) -> Range<usize> {
-    let branch = children[index];
-    let (start, _) = context.source.line_column(branch.start_byte());
-    let end = children[index + 1..]
-        .iter()
-        .find(|sibling| sibling.kind_str() != "comment")
-        .map_or_else(
-            || {
-                // `parent.loc.end.line`, the `end` keyword closing the `case`.
-                let (line, _) = context
-                    .source
-                    .line_column(case.end_byte().saturating_sub(1));
-                line
-            },
-            |next| context.source.line_column(next.start_byte()).0,
-        );
-    start..end
-}
-
 /// `comments_contain_disables?`: whether a `rubocop:disable` of this cop overlaps the branch. The
 /// directives are read only here, where a branch already turned out to be empty and commented.
 fn comments_contain_disables(context: &RuleContext<'_>, lines: &Range<usize>) -> bool {