sonicop 26.8.111 → 26.8.113

data/src/rules/style/ascii_comments.rs

@@ -11,6 +11,8 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         .unwrap_or_default();
     for range in context.comment_ranges() {
         let range = super::comments::parser_range(range, context);
+        // The parser's span for a block comment can run past a file with no final newline.
+        let range = range.start..range.end.min(context.source.text().len());
         let comment = &context.source.text()[range.clone()];
         if comment.is_ascii() {
             continue;

data/src/rules/style/attr.rs

@@ -97,7 +97,7 @@ fn is_class_eval(context: &RuleContext<'_>, block: Node<'_>) -> bool {
 
 /// `each_descendant(:def).any? { |def_node| def_node.method?(:attr) }`.
 fn defines_attr(context: &RuleContext<'_>, node: Node<'_>) -> bool {
-    super::conditional::descendants(node)
+    super::conditional::descendants(node, context)
         .into_iter()
         .filter(|descendant| descendant.kind_str() == "method")
         .any(|definition| {

data/src/rules/style/auto_resource_cleanup.rs

@@ -61,7 +61,7 @@ fn cleans_up(node: Node<'_>, context: &RuleContext<'_>) -> bool {
         return false;
     };
     if parent.kind_str() == "program" {
-        let statements: Vec<Node<'_>> = super::nodes::children(parent)
+        let statements: Vec<Node<'_>> = super::nodes::children_in(parent, context)
             .into_iter()
             .filter(|child| child.kind_str() != "comment")
             .collect();

data/src/rules/style/bitwise_predicate.rs

@@ -95,12 +95,12 @@ fn comparison<'tree>(
 /// `(begin (send _ :& _))`: the two operands of a parenthesized mask.
 fn masked<'tree>(
     node: Node<'tree>,
-    context: &RuleContext<'_>,
+    context: &'tree RuleContext<'_>,
 ) -> Option<(Node<'tree>, Node<'tree>)> {
     if node.kind_str() != "parenthesized_statements" {
         return None;
     }
-    let inner = super::nodes::children(node);
+    let inner = super::nodes::children_in(node, context);
     let [inner] = inner.as_slice() else {
         return None;
     };

data/src/rules/style/block_args.rs

@@ -36,7 +36,7 @@ pub(super) fn implicit(context: &RuleContext<'_>, block: Node<'_>) -> bool {
 /// The part of the body that belongs to this block: a nested block's `_1` is that block's, not
 /// this one's.
 fn scan(context: &RuleContext<'_>, node: Node<'_>, numbered: &mut bool, it: &mut bool) {
-    for child in super::nodes::children(node) {
+    for child in super::nodes::children_in(node, context) {
         if matches!(child.kind_str(), "block" | "do_block" | "lambda") {
             continue;
         }

data/src/rules/style/block_comments.rs

@@ -18,9 +18,18 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         // the grammar stops at the last character of that line.
         let start = node.start_byte();
         let mut end = node.end_byte();
-        if text.as_bytes().get(end) == Some(&b'\n') {
+        // **A file that does not end in a newline still has one to the parser**, and a block
+        // comment's range runs one character past even that. Only the report reaches there; every
+        // read below stays inside the text.
+        let closed_by_newline = text.as_bytes().get(end) == Some(&b'\n');
+        if closed_by_newline {
             end += 1;
         }
+        let reported_end = match closed_by_newline {
+            true => end,
+            false => end + 2,
+        };
+
         // `=begin\n=end` is the shortest block comment the parser accepts; anything shorter would
         // only reach here from a file that does not parse, where no cop runs at all.
         if end - start < BEGIN_LENGTH + 4 {
@@ -61,7 +70,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             replacement: String::new(),
             safe: true,
         });
-        offenses.push(context.offense(MSG, start..end).corrected_by_all(edits));
+        offenses.push(context.offense(MSG, start..reported_end).corrected_by_all(edits));
     }
 }
 

data/src/rules/style/block_delimiters.rs

@@ -7,6 +7,7 @@ use tree_sitter::Node;
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::all_children_iter;
 
 const MSG_MULTILINE: &str = "Avoid using `{...}` for multi-line blocks.";
 const MSG_SINGLE_LINE: &str = "Prefer `{...}` over `do...end` for single-line blocks.";
@@ -26,6 +27,32 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             .setting::<String>("EnforcedStyle")
             .unwrap_or_else(|| "line_count_based".to_owned()),
         braces_required_methods: context.setting("BracesRequiredMethods").unwrap_or_default(),
+        functional_methods: context.setting("FunctionalMethods").unwrap_or_else(|| {
+            ["let", "let!", "subject", "watch"]
+                .iter()
+                .map(|name| (*name).to_owned())
+                .collect()
+        }),
+        procedural_methods: context.setting("ProceduralMethods").unwrap_or_else(|| {
+            [
+                "benchmark",
+                "bm",
+                "bmbm",
+                "create",
+                "each_with_object",
+                "measure",
+                "new",
+                "realtime",
+                "tap",
+                "with_object",
+            ]
+            .iter()
+            .map(|name| (*name).to_owned())
+            .collect()
+        }),
+        procedural_oneliners_may_have_braces: context
+            .setting("AllowBracesOnProceduralOneLiners")
+            .unwrap_or(false),
         allowed_methods: context.setting("AllowedMethods").unwrap_or_else(|| {
             ["lambda", "proc", "it"]
                 .iter()
@@ -84,6 +111,12 @@ struct Cop<'a, 'tree> {
     braces_required_methods: Vec<String>,
     allowed_methods: Vec<String>,
     allowed_patterns: Vec<regex::Regex>,
+    /// `FunctionalMethods`: the ones whose block always yields a value, so braces suit them.
+    functional_methods: Vec<String>,
+    /// `ProceduralMethods`: the ones whose block is run for its effect, so `do ... end` suits.
+    procedural_methods: Vec<String>,
+    /// `AllowBracesOnProceduralOneLiners`.
+    procedural_oneliners_may_have_braces: bool,
 }
 
 /// One block: its delimiters, the call it hangs off, and the body between them.
@@ -98,7 +131,7 @@ struct Block<'t> {
 }
 
 impl<'t> Block<'t> {
-    fn new(context: &RuleContext<'_>, node: Node<'t>) -> Option<Self> {
+    fn new(context: &'t RuleContext<'_>, node: Node<'t>) -> Option<Self> {
         let braces = node.kind_str() == "block";
         let call = node.parent()?;
         // `-> { }` is a block whose call is `lambda` upstream, however the arrow is written.
@@ -109,8 +142,8 @@ impl<'t> Block<'t> {
                 .map(|method| context.source.node_text(method).to_owned())
                 .unwrap_or_default(),
         };
-        let mut cursor = node.walk();
-        let children: Vec<Node<'t>> = node.children(&mut cursor).collect();
+        let _cursor = node.walk();
+        let children: Vec<Node<'t>> = all_children_iter(node, context).collect();
         let begin = *children
             .iter()
             .find(|child| !child.is_named() && matches!(child.kind_str(), "{" | "do"))?;
@@ -164,7 +197,7 @@ impl Cop<'_, '_> {
                 vec![right]
             }
             "element_reference" => {
-                let mut arguments = super::nodes::children(node);
+                let mut arguments = super::nodes::children_in(node, self.context);
                 if node.field("object").is_some() && !arguments.is_empty() {
                     arguments.remove(0);
                 }
@@ -252,11 +285,117 @@ impl Cop<'_, '_> {
                 },
                 false => block.braces,
             },
+            "semantic" => self.semantic_block_style(block),
             // `line_count_based_block_style?`.
             _ => block.multiline != block.braces,
         }
     }
 
+    /// `semantic_block_style?`: braces mark a block whose value is used, `do ... end` one that is
+    /// run for its effect. Which one a block is comes from the method it hangs off and from where
+    /// the block itself sits -- a block whose result nothing reads is procedural whatever it does.
+    fn semantic_block_style(&self, block: &Block<'_>) -> bool {
+        if block.braces {
+            self.functional_methods.contains(&block.method)
+                || self.functional_block(block)
+                || (self.procedural_oneliners_may_have_braces && !block.multiline)
+        } else {
+            self.procedural_methods.contains(&block.method) || !self.return_value_used(block.call)
+        }
+    }
+
+    /// `functional_block?`.
+    fn functional_block(&self, block: &Block<'_>) -> bool {
+        self.return_value_used(block.call) || self.return_value_of_scope(block.call)
+    }
+
+    /// `return_value_used?`: the block feeds an assignment or another call.
+    ///
+    /// The node walked from is upstream's `block`, which the grammar spells as the call the braces
+    /// hang off, so the parent chain reads the same from there.
+    fn return_value_used(&self, node: Node<'_>) -> bool {
+        let Some(parent) = node.parent_of(self.context) else {
+            return false;
+        };
+        match parent.kind_str() {
+            // `node.parent.begin_type?`: parentheses around the block, which pass the question on.
+            "parenthesized_statements" => self.return_value_used(parent),
+            "assignment" | "operator_assignment" => true,
+            // `call_type?`: Parser folds arguments, indexing and non-keyword operators into
+            // `send` nodes. tree-sitter keeps the argument-list wrapper and operator forms.
+            "call" | "method_call" | "argument_list" | "element_reference" | "unary" => true,
+            // Ordinary operators are `send` nodes to Parser, while `&&` / `||` / `and` / `or`
+            // remain keyword operators. The latter make braces functional through
+            // `return_value_of_scope?`, but do not make a `do...end` block's value directly used.
+            "binary" => parent.field("operator").is_some_and(|operator| {
+                !LOGICAL_OPERATORS.contains(&self.context.source.node_text(operator))
+            }),
+            _ => false,
+        }
+    }
+
+    /// `return_value_of_scope?`: the block sits where a value is read off -- a condition, an
+    /// operand, an element, or the last expression of whatever encloses it.
+    fn return_value_of_scope(&self, node: Node<'_>) -> bool {
+        let Some(parent) = node.parent_of(self.context) else {
+            return false;
+        };
+        if matches!(
+            parent.kind_str(),
+            "if" | "unless"
+                | "elsif"
+                | "if_modifier"
+                | "unless_modifier"
+                | "while"
+                | "until"
+                | "while_modifier"
+                | "until_modifier"
+                | "case"
+                | "case_match"
+                | "conditional"
+                | "array"
+                | "range"
+        ) {
+            return true;
+        }
+        // `operator_keyword?`: `and`, `or`, `not`.
+        if parent.kind_str() == "binary"
+            && parent.field("operator").is_some_and(|operator| {
+                LOGICAL_OPERATORS.contains(&&self.context.source.text()[operator.byte_range()])
+            })
+        {
+            return true;
+        }
+        if parent.kind_str() == "unary" {
+            return true;
+        }
+        // `return false unless (parent = node.parent)`: a lone top-level statement **has no
+        // parent** upstream. The grammar always hands back a `program`, whose only child is that
+        // statement -- reading it as "the last thing the parent holds" made every such block look
+        // like the value of its scope, and `each { |x| x }` went unreported under `semantic`.
+        if parent.kind_str() == "program" && super::nodes::children(parent).len() == 1 {
+            return false;
+        }
+        // `parent.children.last == node`: the block is the last thing the parent holds, so its
+        // value is the parent's.
+        let children = super::nodes::children(parent);
+        // Parser represents a method-level rescue as a `rescue` whose protected body is a
+        // separate `begin`. tree-sitter appends the rescue clauses to one `body_statement`; the
+        // last expression before the first clause is the value of that virtual begin.
+        let value_children = match parent.kind_str() {
+            "body_statement" => {
+                &children[..children
+                    .iter()
+                    .position(|child| matches!(child.kind_str(), "rescue" | "else" | "ensure"))
+                    .unwrap_or(children.len())]
+            }
+            _ => children.as_slice(),
+        };
+        value_children
+            .last()
+            .is_some_and(|last| last.id() == node.id())
+    }
+
     fn braces_required_method(&self, method: &str) -> bool {
         self.braces_required_methods
             .iter()
@@ -271,7 +410,7 @@ impl Cop<'_, '_> {
         let Some(body) = block.body() else {
             return false;
         };
-        let clauses = super::nodes::children(body);
+        let clauses = super::nodes::children_in(body, self.context);
         if clauses.iter().any(|child| child.kind_str() == "ensure") {
             return true;
         }
@@ -351,7 +490,7 @@ impl Cop<'_, '_> {
         // `begin_required?`: a protected body needs its own `begin` once the keywords are gone.
         if block.multiline
             && let Some(body) = block.body()
-            && super::nodes::children(body)
+            && super::nodes::children_in(body, self.context)
                 .iter()
                 .any(|child| matches!(child.kind_str(), "rescue" | "ensure"))
         {
@@ -445,10 +584,15 @@ fn get_blocks(node: Node<'_>, out: &mut Vec<Range<usize>>) {
 /// Whether the call carrying the block is itself the receiver of another one.
 fn chained(call: Node<'_>) -> bool {
     call.parent().is_some_and(|parent| {
-        matches!(parent.kind_str(), "call" | "method_call")
-            && parent
-                .field("receiver")
-                .is_some_and(|receiver| receiver.id() == call.id())
+        let receiver = match parent.kind_str() {
+            "call" | "method_call" => parent.field("receiver"),
+            // `foo { ... }[key]` is a `send` of `:[]` upstream and therefore extends the same
+            // chain as a dotted call. The grammar gives indexing its own node and calls the
+            // receiver `object`.
+            "element_reference" => parent.field("object"),
+            _ => None,
+        };
+        receiver.is_some_and(|receiver| receiver.id() == call.id())
     })
 }
 

data/src/rules/style/case_equality.rs

@@ -3,6 +3,7 @@ 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_iter;
 
 const MSG: &str = "Avoid the use of the case equality operator `===`.";
 
@@ -71,6 +72,10 @@ fn case_equality<'tree>(
             ))
         }
         _ => {
+            // `on_send` is not aliased to `on_csend`: `a&.===(b)` is outside this cop.
+            if !crate::rules::send_node::is_plain_send(node, context) {
+                return None;
+            }
             let method = node.field("method")?;
             if context.source.node_text(method) != "===" {
                 return None;
@@ -99,8 +104,8 @@ fn replacement(
     let _ = node;
     let source = context.source.node_text(left);
     if left.kind_str() == "parenthesized_statements" {
-        let mut cursor = left.walk();
-        let inner = left.named_children(&mut cursor).next()?;
+        let _cursor = left.walk();
+        let inner = named_children_iter(left, context).next()?;
         if inner.kind_str() != "range" {
             return None;
         }

data/src/rules/style/case_like_if.rs

@@ -39,7 +39,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let branches = branch_conditions(node);
         // `elsif_conditional?` and `min_branches_count?`: the chain has to be an `if`/`elsif` one
         // with enough arms to be worth a `case`.
-        if branches.len() < 2 || branches.len() < minimum {
+        if branches.len() < 2 || branch_count(node) < minimum {
             continue;
         }
         let Some(target) = find_target(context, branches[0]) else {
@@ -88,6 +88,30 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     }
 }
 
+/// `if_conditional_branches`: the arms a conditional chain has, which is what `MinBranchesCount`
+/// is counted against. **A ternary is an `if` upstream**, so an `else` holding one contributes its
+/// own arm -- `if a / elsif b / else c ? d : e` has three, not two.
+fn branch_count(node: Node<'_>) -> usize {
+    let mut count = 0;
+    let mut current = Some(node);
+    while let Some(branch) = current {
+        if !matches!(branch.kind_str(), "if" | "elsif" | "conditional") {
+            break;
+        }
+        count += 1;
+        current = match branch.field("alternative") {
+            Some(alternative) if alternative.kind_str() == "else" => {
+                match super::nodes::children(alternative).as_slice() {
+                    [only] => Some(*only),
+                    _ => None,
+                }
+            }
+            other => other,
+        };
+    }
+    count
+}
+
 /// `branch_conditions`: the condition of every `if`/`elsif` in the chain.
 fn branch_conditions<'t>(node: Node<'t>) -> Vec<Node<'t>> {
     let mut conditions = Vec::new();
@@ -159,7 +183,7 @@ fn collect_conditions(
     conditions: &mut Vec<String>,
 ) -> bool {
     if node.kind_str() == "parenthesized_statements" {
-        let Some(inner) = super::nodes::children(node).into_iter().next() else {
+        let Some(inner) = super::nodes::children_in(node, context).into_iter().next() else {
             return false;
         };
         return collect_conditions(context, inner, target, conditions);

data/src/rules/style/class_and_module_children.rs

@@ -3,6 +3,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::all_children_of;
+use crate::rules::send_node::named_children_iter;
 
 const NESTED_MSG: &str = "Use nested module/class definitions instead of compact style.";
 const COMPACT_MSG: &str = "Use compact module/class definition instead of nested style.";
@@ -61,12 +63,20 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 
         if style == "nested" {
             check_nested(context, node, name, offenses);
-        } else if matches!(body_statements(node).as_slice(), [only] if matches!(only.kind_str(), "class" | "module"))
+        } else if let [only] = body_statements(node).as_slice()
+            && matches!(only.kind_str(), "class" | "module")
         {
-            // The compact correction rewrites the body's indentation as well, which is not
-            // expressible as the single edit an offense carries here, so the offense is reported
-            // without one.
-            offenses.push(context.offense(COMPACT_MSG, name.byte_range()));
+            let inner_style = match only.kind_str() == "class" {
+                true => for_classes.as_str(),
+                false => for_modules.as_str(),
+            };
+            let offense = context.offense(COMPACT_MSG, name.byte_range());
+            offenses.push(
+                match compact_correction(context, node, name, *only, inner_style) {
+                    Some(edits) => offense.corrected_by_all(edits),
+                    None => offense,
+                },
+            );
         }
     }
 }
@@ -158,9 +168,9 @@ fn nested_correction(
     if closing.kind_str() != "end" {
         return None;
     }
-    let mut cursor = name.walk();
-    let separator = name
-        .children(&mut cursor)
+    let _cursor = name.walk();
+    let separator = all_children_of(name, context)
+        .into_iter()
         .find(|child| child.kind_str() == "::")?;
 
     let (_, column) = context.source.line_column(node.start_byte());
@@ -200,6 +210,122 @@ fn nested_correction(
     ])
 }
 
+/// `compact_definition`: `class Foo` holding nothing but `class Bar` becomes `class Foo::Bar`.
+///
+/// Three edits, as upstream: the header up to the inner name, the inner `end`, and the body's
+/// indentation. The last one is a run of per-line edits rather than a single replacement, so the
+/// cops correcting inside the body still can in the same pass.
+fn compact_correction(
+    context: &RuleContext<'_>,
+    node: Node<'_>,
+    name: Node<'_>,
+    inner: Node<'_>,
+    inner_style: &str,
+) -> Option<Vec<Edit>> {
+    // Compacting produces a definition whose own style resolves to `nested`, which would make the
+    // correction ping-pong between the two forms.
+    if inner_style == "nested" {
+        return None;
+    }
+    let keyword = node.child(0)?;
+    let inner_name = inner.field("name")?;
+    let inner_end = inner.child(inner.child_count().saturating_sub(1) as u32)?;
+    if inner_end.kind_str() != "end" {
+        return None;
+    }
+    // The cop is declared `SafeAutoCorrect: false`: compacting removes a definition of the
+    // namespace, so the result needs it defined elsewhere.
+    let safe = false;
+    let compacted = format!(
+        "{} {}::{}",
+        inner.kind_str(),
+        context.source.node_text(name),
+        context.source.node_text(inner_name)
+    );
+    // `compact_replacement`: the comments `ast_with_comments` ties to the inner definition stand
+    // inside the range being replaced, so they have to be written back above the compacted line.
+    let comments = leading_comments(context, inner);
+    let replacement = match comments.is_empty() {
+        true => compacted,
+        false => format!("{}\n{compacted}", comments.join("\n")),
+    };
+    let mut edits = vec![Edit {
+        start: keyword.start_byte(),
+        end: inner_name.end_byte(),
+        replacement,
+        safe,
+    }];
+
+    // `remove_end`: the inner `end`, the blanks in front of it and the line break after it.
+    let same_line = inner_name.end_position().row == inner_end.start_position().row;
+    let leading = leading_spaces(context, inner.start_byte());
+    let removal_start = match same_line {
+        true => inner_name.end_byte(),
+        false => inner_end.start_byte().saturating_sub(leading.len()),
+    };
+    let adjustment = match context.source.text().as_bytes().get(removal_start) {
+        Some(b';') => 0,
+        _ => 1,
+    };
+    edits.push(Edit {
+        start: removal_start,
+        end: (inner_end.end_byte() + adjustment).min(context.source.text().len()),
+        replacement: String::new(),
+        safe,
+    });
+
+    edits.extend(unindent(context, node, inner, inner_name.end_byte(), safe));
+    Some(edits)
+}
+
+/// `unindent`: the body moves left by the difference between the configured width and the
+/// indentation the inner definition gave it.
+fn unindent(
+    context: &RuleContext<'_>,
+    node: Node<'_>,
+    inner: Node<'_>,
+    header_end: usize,
+    safe: bool,
+) -> Vec<Edit> {
+    let Some(last) = body_statements(inner).last().copied() else {
+        return Vec::new();
+    };
+    let outer_indent = leading_spaces(context, node.start_byte()).chars().count();
+    let inner_indent = leading_spaces(context, last.start_byte()).chars().count();
+    if outer_indent == inner_indent {
+        return Vec::new();
+    }
+    let width: usize = context
+        .setting("IndentationWidth")
+        .or_else(|| context.setting_of("Layout/IndentationWidth", "Width"))
+        .unwrap_or(2);
+    let Some(delta) = inner_indent.checked_sub(width).filter(|delta| *delta > 0) else {
+        return Vec::new();
+    };
+    // Only the lines the header edit does not already cover.
+    let first = context.source.line_column(header_end).0 + 1;
+    let last_line = context.source.line_column(node.end_byte()).0;
+    (first..last_line)
+        .filter_map(|line| {
+            let text = context.source.line(line);
+            let removable = text
+                .chars()
+                // Upstream removes a run of literal spaces. A tab is one source character but
+                // does not match that run, so tab-indented bodies remain byte-for-byte intact.
+                .take_while(|character| *character == ' ')
+                .count()
+                .min(delta);
+            let start = context.source.line_start(line);
+            (removable > 0).then(|| Edit {
+                start,
+                end: start + removable,
+                replacement: String::new(),
+                safe,
+            })
+        })
+        .collect()
+}
+
 /// `padding.sub(' ' * column, '')`: one run of that many spaces comes back out of the padding.
 fn drop_one_run(padding: &str, spaces: usize) -> String {
     let run = " ".repeat(spaces);
@@ -232,8 +358,8 @@ fn namespace_keyword(context: &RuleContext<'_>, node: Node<'_>, name: Node<'_>)
         {
             return "class";
         }
-        let mut cursor = current.walk();
-        stack.extend(current.named_children(&mut cursor));
+        let _cursor = current.walk();
+        stack.extend(named_children_iter(current, context));
     }
     "module"
 }
@@ -264,6 +390,32 @@ fn normalized(text: &str) -> String {
         .collect()
 }
 
+/// `ast_with_comments[node]` for a definition: the run of comment lines written directly above it,
+/// in source order and without their indentation, which is what `Comment#text` gives.
+fn leading_comments(context: &RuleContext<'_>, node: Node<'_>) -> Vec<String> {
+    let opening = context.source.line_column(node.start_byte()).0;
+    let mut collected = Vec::new();
+    let mut probe = opening;
+    while probe > 1 {
+        let line = context.source.line(probe - 1);
+        let text = line.trim();
+        // A `#` opening a line is a comment only if the tokeniser agrees -- a heredoc body can
+        // hold anything.
+        let is_comment = text.starts_with('#')
+            && context
+                .comment_ranges()
+                .iter()
+                .any(|comment| context.source.line_column(comment.start).0 == probe - 1);
+        if !is_comment {
+            break;
+        }
+        collected.push(text.to_owned());
+        probe -= 1;
+    }
+    collected.reverse();
+    collected
+}
+
 /// `leading_spaces`: the indentation of the line the definition opens on.
 fn leading_spaces(context: &RuleContext<'_>, offset: usize) -> String {
     let (line, _) = context.source.line_column(offset);

data/src/rules/style/class_methods.rs

@@ -17,7 +17,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         };
         // Only the statements the body holds directly are looked at: a definition nested inside a
         // `begin` or a conditional is not a child of the class body upstream either.
-        for definition in super::nodes::children(body) {
+        for definition in super::nodes::children_in(body, context) {
             if definition.kind_str() != "singleton_method" {
                 continue;
             }

data/src/rules/style/class_methods_definitions.rs

@@ -60,6 +60,15 @@ fn check_singleton_class(node: Node<'_>, context: &RuleContext<'_>, offenses: &m
     if ranges.iter().any(|range| range.end >= node.end_byte()) {
         return;
     }
+    // A definition written on the `class << self` line itself leaves the correction asking the
+    // rewriter for a range it cannot build (`RangeError`), and the offense goes with it.
+    let keyword_line = context.source.line_column(node.start_byte()).0;
+    if definitions
+        .iter()
+        .any(|definition| context.source.line_column(definition.start_byte()).0 == keyword_line)
+    {
+        return;
+    }
     let mut rewritten: Vec<String> = definitions
         .iter()
         .zip(&ranges)