sonicop 26.8.113 → 26.9.100

data/src/rules/lint/literals.rs

@@ -55,58 +55,99 @@ const RECURSIVE_METHODS: &[&str] = &["==", "===", "!=", "<=", ">=", ">", "<", "*
 /// Reachable from `style` too: `Style/YodaCondition` asks the same question of a comparison's two
 /// operands.
 pub(crate) fn recursive_basic_literal(node: Node<'_>, context: &RuleContext<'_>) -> bool {
-    match node.kind_str() {
-        kind if BASIC.contains(&kind) => true,
-        // `emit_file_line_as_literals`: the parser resolves these before a cop sees them, so what
-        // reaches one is the `str` or the `int` they stood for rather than the keyword.
-        "identifier" => matches!(context.source.node_text(node), "__FILE__" | "__LINE__"),
-        // A quoted literal interpolates or it does not, and only the plain one is basic -- but a
-        // `dstr` and a `dsym` are composite literals, so both answers come out the same here as
-        // long as everything interpolated into them is a literal too.
-        "string" | "delimited_symbol" => !has_interpolation(node) || all_children(node, context),
-        kind if COMPOSITE.contains(&kind) => all_children(node, context),
-        // `a && b` and `a || b` are `and`/`or` upstream, which recurse; every other binary operator
-        // is a `send`, which recurses only for the ten that keep a literal literal.
-        "binary" => {
-            let Some(operator) = node.field("operator") else {
-                return false;
-            };
-            let text = context.source.node_text(operator);
-            (matches!(text, "&&" | "and" | "||" | "or") || RECURSIVE_METHODS.contains(&text))
-                && all_children(node, context)
-        }
-        // The parser folds a leading sign into the literal it precedes; `!x` stays a `send`.
-        "unary" => {
-            let Some(operator) = node.field("operator") else {
-                return false;
-            };
-            matches!(context.source.node_text(operator), "-" | "+" | "!")
-                && node
-                    .field("operand")
-                    .is_some_and(|operand| recursive_basic_literal(operand, context))
-        }
-        "call" => {
-            node.field("method")
-                .is_some_and(|method| RECURSIVE_METHODS.contains(&context.source.node_text(method)))
-                && all_children(node, context)
+    // The predicate is a conjunction over a subtree, so it is answered with a stack rather than by
+    // recursing: a nested literal nests the tree once per bracket, and this is asked of every hash
+    // key of every file. `AstIndex::collect` is iterative for the same reason -- a rayon worker's
+    // stack is far smaller than the main thread's, and a recursion deep enough to exhaust it aborts
+    // the process rather than failing one file. Nothing below has a side effect, so answering the
+    // queued questions in any order gives the same answer the nested `&&` gave.
+    let mut stack = vec![Question::Literal(node)];
+    while let Some(question) = stack.pop() {
+        match question {
+            Question::Literal(node) => match node.kind_str() {
+                kind if BASIC.contains(&kind) => {}
+                // `emit_file_line_as_literals`: the parser resolves these before a cop sees them,
+                // so what reaches one is the `str` or the `int` they stood for rather than the
+                // keyword.
+                "identifier" => {
+                    if !matches!(context.source.node_text(node), "__FILE__" | "__LINE__") {
+                        return false;
+                    }
+                }
+                // A quoted literal interpolates or it does not, and only the plain one is basic --
+                // but a `dstr` and a `dsym` are composite literals, so both answers come out the
+                // same here as long as everything interpolated into them is a literal too.
+                "string" | "delimited_symbol" => {
+                    if has_interpolation(node) {
+                        stack.push(Question::Children(node));
+                    }
+                }
+                kind if COMPOSITE.contains(&kind) => stack.push(Question::Children(node)),
+                // `a && b` and `a || b` are `and`/`or` upstream, which recurse; every other binary
+                // operator is a `send`, which recurses only for the ten that keep a literal
+                // literal.
+                "binary" => {
+                    let Some(operator) = node.field("operator") else {
+                        return false;
+                    };
+                    let text = context.source.node_text(operator);
+                    if !matches!(text, "&&" | "and" | "||" | "or")
+                        && !RECURSIVE_METHODS.contains(&text)
+                    {
+                        return false;
+                    }
+                    stack.push(Question::Children(node));
+                }
+                // The parser folds a leading sign into the literal it precedes; `!x` stays a
+                // `send`.
+                "unary" => {
+                    let Some(operator) = node.field("operator") else {
+                        return false;
+                    };
+                    if !matches!(context.source.node_text(operator), "-" | "+" | "!") {
+                        return false;
+                    }
+                    let Some(operand) = node.field("operand") else {
+                        return false;
+                    };
+                    stack.push(Question::Literal(operand));
+                }
+                "call" => {
+                    let literal_carrying = node.field("method").is_some_and(|method| {
+                        RECURSIVE_METHODS.contains(&context.source.node_text(method))
+                    });
+                    if !literal_carrying {
+                        return false;
+                    }
+                    stack.push(Question::Children(node));
+                }
+                _ => return false,
+            },
+            // `children.compact.all?(&:recursive_basic_literal?)`.
+            Question::Children(node) => {
+                for child in named_children_of(node, context) {
+                    match child.kind_str() {
+                        "comment" => {}
+                        // The parts a quoted literal is written from are not nodes upstream at all:
+                        // the text between the delimiters is the value, and only what is
+                        // interpolated is a child.
+                        "string_content" | "escape_sequence" | "heredoc_content" => {}
+                        "interpolation" => stack.push(Question::Children(child)),
+                        _ => stack.push(Question::Literal(child)),
+                    }
+                }
+            }
         }
-        _ => false,
     }
+    true
 }
 
-/// `children.compact.all?(&:recursive_basic_literal?)`.
-fn all_children(node: Node<'_>, context: &RuleContext<'_>) -> bool {
-    let _cursor = node.walk();
-    named_children_of(node, context)
-        .into_iter()
-        .filter(|child| child.kind_str() != "comment")
-        .all(|child| match child.kind_str() {
-            // The parts a quoted literal is written from are not nodes upstream at all: the text
-            // between the delimiters is the value, and only what is interpolated is a child.
-            "string_content" | "escape_sequence" | "heredoc_content" => true,
-            "interpolation" => all_children(child, context),
-            _ => recursive_basic_literal(child, context),
-        })
+/// One half of [`recursive_basic_literal`]'s question, queued rather than recursed into.
+enum Question<'tree> {
+    /// `node.recursive_basic_literal?`.
+    Literal(Node<'tree>),
+    /// `node.children.compact.all?(&:recursive_basic_literal?)`.
+    Children(Node<'tree>),
 }
 
 /// `node.const_type?`: a constant, however it was reached.

data/src/rules/lint/loop.rs

@@ -24,8 +24,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             Some(keyword) => keyword,
             None => continue,
         };
-        let last = u32::try_from(body.child_count())
-            .unwrap_or(0)
+        let last = body.child_count()
             .saturating_sub(1);
         let (Some(open), Some(close)) = (body.child(0), body.child(last)) else {
             continue;

data/src/rules/lint/nil_receiver.rs

@@ -394,7 +394,7 @@ fn csend_root_receiver<'tree>(node: Node<'tree>, context: &RuleContext<'_>) -> O
 fn is_safe_navigation(node: Node<'_>, context: &RuleContext<'_>) -> bool {
     node.kind_str() == "call"
         && (0..node.child_count())
-            .filter_map(|index| node.child(index as u32))
+            .filter_map(|index| node.child(index))
             .any(|child| context.source.node_text(child) == "&.")
 }
 

data/src/rules/lint/node_equality.rs

@@ -174,7 +174,10 @@ fn named_children_with_fields<'tree>(
     }
     loop {
         if cursor.node().is_named() {
-            children.push((cursor.field_name(), cursor.node()));
+            children.push((
+                super::super::field_name_for_id(cursor.field_id()),
+                cursor.node(),
+            ));
         }
         if !cursor.goto_next_sibling() {
             return children;
@@ -299,7 +302,7 @@ fn quoted_value(node: Node<'_>, context: &RuleContext<'_>) -> Option<Vec<u8>> {
         return None;
     }
     let open = node.child(0)?;
-    let close = node.child(u32::try_from(node.child_count()).ok()?.saturating_sub(1))?;
+    let close = node.child(node.child_count().saturating_sub(1))?;
     if open.id() == close.id() || close.start_byte() < open.end_byte() {
         return None;
     }

data/src/rules/lint/non_atomic_file_operation.rs

@@ -176,7 +176,7 @@ fn corrections(
             safe: true,
         });
     } else if let Some(end) = conditional
-        .child(conditional.child_count().saturating_sub(1) as u32)
+        .child(conditional.child_count().saturating_sub(1))
         .filter(|end| context.source.node_text(*end) == "end")
     {
         edits.push(Edit {

data/src/rules/lint/regexp.rs

@@ -20,7 +20,7 @@ pub(super) struct Captures {
 /// The text between a regexp literal's delimiters, and whether it was written with the `x` flag.
 pub(super) fn pattern<'a>(node: Node<'_>, context: &'a RuleContext<'_>) -> Option<(&'a str, bool)> {
     let opening = node.child(0)?;
-    let closing = node.child(u32::try_from(node.child_count()).ok()?.checked_sub(1)?)?;
+    let closing = node.child(node.child_count().checked_sub(1)?)?;
     if closing.start_byte() < opening.end_byte() {
         return None;
     }

data/src/rules/lint/suppressed_exception.rs

@@ -28,7 +28,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             // The offense covers the `rescue` keyword and what follows it, not the guarded body.
             "rescue_modifier" => {
                 let keyword = (0..node.child_count())
-                    .filter_map(|index| node.child(index as u32))
+                    .filter_map(|index| node.child(index))
                     .find(|child| context.source.node_text(*child) == "rescue");
                 match keyword {
                     Some(keyword) => keyword.start_byte()..node.end_byte(),

data/src/rules/lint/syntax.rs

@@ -833,7 +833,7 @@ fn endless_in_block_recovery(node: Node<'_>, context: &RuleContext<'_>, out: &mu
         return;
     };
     let Some(brace) = block
-        .child(block.child_count().saturating_sub(1) as u32)
+        .child(block.child_count().saturating_sub(1))
         .filter(|last| last.kind_str() == "}")
     else {
         return;

data/src/rules/lint/unreachable_loop.rs

@@ -268,11 +268,24 @@ fn is_loop_shape(node: Node<'_>, context: &RuleContext<'_>, allowed: &[&'static
 }
 
 /// `each_descendant(:next, :redo).any?`, without descending into `skip`.
+///
+/// Iterative rather than recursive, for the reason `AstIndex::collect` is: a rayon worker's stack
+/// is far smaller than the main thread's, and a `while` condition written as one long chain nests
+/// as deeply as it is long -- a recursive walk aborts the whole process on it rather than failing
+/// one file.
 fn has_continue(node: Node<'_>, skip: Option<Node<'_>>) -> bool {
-    let mut cursor = node.walk();
-    node.named_children(&mut cursor)
-        .filter(|child| skip.is_none_or(|skip| skip.id() != child.id()))
-        .any(|child| CONTINUE.contains(&child.kind_str()) || has_continue(child, skip))
+    let mut stack = Vec::new();
+    crate::rules::push_named_children(node, &mut stack);
+    while let Some(current) = stack.pop() {
+        if skip.is_some_and(|skip| skip.id() == current.id()) {
+            continue;
+        }
+        if CONTINUE.contains(&current.kind_str()) {
+            return true;
+        }
+        crate::rules::push_named_children(current, &mut stack);
+    }
+    false
 }
 
 /// `conditional_continue_keyword?`: the last `or` written anywhere in the break statement, when its
@@ -285,16 +298,19 @@ fn conditional_continue(node: Node<'_>) -> bool {
         .is_some_and(|right| CONTINUE.contains(&right.kind_str()))
 }
 
+/// The last `or` of `node`'s subtree in depth-first pre-order, `node` itself excluded.
+///
+/// Iterative for the same reason [`has_continue`] is: `a or b or c or …` nests once per operand,
+/// and the recursion this replaced was as deep as the chain is long.
 fn last_or<'tree>(node: Node<'tree>) -> Option<Node<'tree>> {
     let mut found = None;
-    let mut cursor = node.walk();
-    for child in node.named_children(&mut cursor) {
-        if is_or(child) {
-            found = Some(child);
-        }
-        if let Some(inner) = last_or(child) {
-            found = Some(inner);
+    let mut stack = Vec::new();
+    crate::rules::push_named_children(node, &mut stack);
+    while let Some(current) = stack.pop() {
+        if is_or(current) {
+            found = Some(current);
         }
+        crate::rules::push_named_children(current, &mut stack);
     }
     found
 }

data/src/rules/lint/variable_force.rs

@@ -1603,7 +1603,7 @@ fn field_name(
     }
     loop {
         if cursor.node().id() == child.id() {
-            return cursor.field_name();
+            return super::super::field_name_for_id(cursor.field_id());
         }
         if !cursor.goto_next_sibling() {
             return None;

data/src/rules/metrics/locals.rs

@@ -507,7 +507,7 @@ pub(super) fn field_name(
     }
     loop {
         if cursor.node().id() == child.id() {
-            return cursor.field_name();
+            return super::super::field_name_for_id(cursor.field_id());
         }
         if !cursor.goto_next_sibling() {
             return None;

data/src/rules/mod.rs

@@ -1,5 +1,6 @@
 use std::cell::OnceCell;
 use std::collections::HashMap;
+use std::num::NonZeroU16;
 use std::ops::Range;
 use std::sync::LazyLock;
 
@@ -572,12 +573,20 @@ impl<'a> Iterator for Children<'a> {
 /// Every field name the grammar has, by field id, so a recorded id can be turned back into the
 /// `&'static str` the cops compare against.
 static FIELD_NAMES: LazyLock<Vec<Option<&'static str>>> = LazyLock::new(|| {
-    let language = node_ext::language();
-    (0..=language.field_count() as u16)
-        .map(|id| language.field_name_for_id(id))
+    (0..=node_ext::LANGUAGE.field_count() as u16)
+        .map(|id| node_ext::LANGUAGE.field_name_for_id(id))
         .collect()
 });
 
+/// The field name a field id stands for, for a node the index does not know.
+///
+/// `TreeCursor::field_name` answers the same question, but since tree-sitter 0.27 its answer
+/// borrows from the tree, and the callers hand the name on as `&'static str`. Going through the
+/// table keeps the lifetime and skips the C lookup besides.
+pub(in crate::rules) fn field_name_for_id(id: Option<NonZeroU16>) -> Option<&'static str> {
+    FIELD_NAMES.get(id?.get() as usize).copied().flatten()
+}
+
 /// The value [`AstIndex::parent_of`] carries for the root.
 const NO_PARENT: u32 = u32::MAX;
 
@@ -917,7 +926,9 @@ fn merge_touching_ranges(ranges: &mut Vec<Range<usize>>) {
 mod tests {
     use std::collections::HashSet;
 
-    use super::{AstIndex, merge_touching_ranges, rule_names, rules};
+    use super::{
+        AstIndex, RuleContext, field_name_for_id, merge_touching_ranges, rule_names, rules,
+    };
     use crate::config::Config;
     use crate::rules::node_ext::NodeExt;
     use crate::source::is_protected;
@@ -1079,6 +1090,27 @@ mod tests {
             index.parent_in_tree(call).map(|found| found.id()),
             call.parent().map(|found| found.id())
         );
+
+        // The same question asked through a context rather than the index. `named_children_of`
+        // recursed into itself here rather than walking, so a cop handing it a fragment node never
+        // returned.
+        let source = crate::source::SourceFile::new("test.rb", "foo(1)\n".to_owned());
+        let config = Config::load_with_options(None, std::path::Path::new("/"), true)
+            .expect("the vendored default configuration loads");
+        let rule = rules().next().expect("the registry is not empty");
+        let context = RuleContext::new(
+            &source,
+            &index,
+            &config,
+            rule,
+            crate::diagnostic::Severity::Convention,
+            false,
+        );
+        assert!(context.named_children(call).is_none());
+        assert_eq!(
+            crate::rules::send_node::named_children_of(call, &context),
+            expected
+        );
     }
 
     /// The registry is a static built from the department tables, so iteration order cannot vary
@@ -1089,4 +1121,51 @@ mod tests {
         let second: Vec<&str> = rules().map(|rule| rule.name).collect();
         assert_eq!(first, second);
     }
+
+    /// The table has to answer what `TreeCursor::field_name` answers, for every node of a real
+    /// file and for a node of a tree the index never saw.
+    ///
+    /// Five cops read the field a node fills out of the table rather than off the cursor, because
+    /// since tree-sitter 0.27 the cursor's answer borrows from the tree while theirs is
+    /// `&'static str`. A field the table named differently would make a cop tell the two sides of
+    /// a range apart wrongly, which is what the field is there for.
+    #[test]
+    fn the_field_table_answers_what_the_cursor_answers() {
+        let mut parser = tree_sitter::Parser::new();
+        parser
+            .set_language(&tree_sitter_ruby::LANGUAGE.into())
+            .expect("the Ruby grammar loads");
+        let tree = parser
+            .parse(
+                "class Foo\n  def bar(a = 1, &block)\n    @x ||= a.map { |v| v[1..] }\n\
+                 rescue StandardError => e\n    raise e if 10.. === a\n  end\nend\n",
+                None,
+            )
+            .expect("the source parses");
+
+        let mut stack = vec![tree.root_node()];
+        let (mut seen, mut named) = (0, 0);
+        while let Some(node) = stack.pop() {
+            let mut cursor = node.walk();
+            if !cursor.goto_first_child() {
+                continue;
+            }
+            loop {
+                assert_eq!(
+                    field_name_for_id(cursor.field_id()),
+                    cursor.field_name(),
+                    "field of {:?} under {node:?}",
+                    cursor.node()
+                );
+                seen += 1;
+                named += usize::from(cursor.field_name().is_some());
+                stack.push(cursor.node());
+                if !cursor.goto_next_sibling() {
+                    break;
+                }
+            }
+        }
+        assert!(seen > 30, "the sample has to reach a variety of children");
+        assert!(named > 10, "and enough of them have to fill a field");
+    }
 }

data/src/rules/naming/support.rs

@@ -47,7 +47,7 @@ fn field(node: Node<'_>) -> Option<&'static str> {
     }
     loop {
         if cursor.node().id() == node.id() {
-            return cursor.field_name();
+            return super::super::field_name_for_id(cursor.field_id());
         }
         if !cursor.goto_next_sibling() {
             return None;

data/src/rules/node_ext.rs

@@ -17,9 +17,14 @@ use tree_sitter::{Language, Node};
 
 use crate::rules::RuleContext;
 
-pub(in crate::rules) fn language() -> Language {
-    tree_sitter_ruby::LANGUAGE.into()
-}
+/// The grammar itself, resolved once and kept for the life of the process.
+///
+/// Since tree-sitter 0.27 the name tables borrow from the `Language` they were read out of rather
+/// than being `&'static str` outright, so a `Language` built per call cannot outlive the name it
+/// hands back. Holding it in a `static` is what lets [`NodeExt::kind_str`] and `FIELD_NAMES` keep
+/// answering `&'static str`, which the several thousand call sites compare against.
+pub(in crate::rules) static LANGUAGE: LazyLock<Language> =
+    LazyLock::new(|| tree_sitter_ruby::LANGUAGE.into());
 
 /// The field ids the codebase asks for, resolved from the grammar once.
 ///
@@ -31,9 +36,8 @@ macro_rules! field_ids {
         struct FieldIds { $($field: u16,)+ }
 
         static FIELD_IDS: LazyLock<FieldIds> = LazyLock::new(|| {
-            let language = language();
             FieldIds {
-                $($field: language
+                $($field: LANGUAGE
                     .field_id_for_name($name)
                     .map_or(0, NonZeroU16::get),)+
             }
@@ -79,10 +83,9 @@ field_ids! {
 
 /// Every node kind the grammar can produce, indexed by the id `Node::kind_id` answers with.
 static KIND_NAMES: LazyLock<Vec<&'static str>> = LazyLock::new(|| {
-    let language = language();
-    (0..language.node_kind_count())
+    (0..LANGUAGE.node_kind_count())
         .map(|id| {
-            language
+            LANGUAGE
                 .node_kind_for_id(id as u16)
                 .expect("every id below the count names a kind")
         })
@@ -106,10 +109,14 @@ impl<'tree> NodeExt<'tree> for Node<'tree> {
     fn kind_str(&self) -> &'static str {
         match KIND_NAMES.get(self.kind_id() as usize) {
             Some(kind) => kind,
-            // A kind the table does not carry cannot happen for a tree this grammar produced, but
-            // answering from the C API rather than panicking keeps a grammar upgrade from taking
-            // the run down.
-            None => self.kind(),
+            // `ERROR` and `_ERROR` carry ids above the kind count -- 65535 and 65534 against 368
+            // kinds -- so this arm is the ordinary path for them, and `ts_language_symbol_name`
+            // names both. It asks the grammar the same question `Node::kind` does, through the
+            // `static` so the answer is still `'static`. The `unwrap_or` is for an id neither the
+            // table nor the grammar knows, which no node this grammar produced can carry: `ERROR`
+            // is the honest name for a node that cannot be placed, and `Node::kind` would abort
+            // the run there.
+            None => LANGUAGE.node_kind_for_id(self.kind_id()).unwrap_or("ERROR"),
         }
     }
 
@@ -130,12 +137,12 @@ impl<'tree> NodeExt<'tree> for Node<'tree> {
 
 #[cfg(test)]
 mod tests {
-    use super::{NodeExt, language};
+    use super::{LANGUAGE, NodeExt};
     use tree_sitter::Parser;
 
     fn tree(source: &str) -> tree_sitter::Tree {
         let mut parser = Parser::new();
-        parser.set_language(&language()).unwrap();
+        parser.set_language(&LANGUAGE).unwrap();
         parser.parse(source, None).unwrap()
     }
 
@@ -187,4 +194,28 @@ mod tests {
         let tree = tree("a.b(1)\n");
         assert!(tree.root_node().field("nonexistent").is_none());
     }
+
+    /// `ERROR` carries a kind id above the kind count, so it is the fallback arm of
+    /// [`NodeExt::kind_str`] that names it -- and `Lint/Syntax` rests on that name. The arm was a
+    /// call to `Node::kind` until tree-sitter 0.27 tied that answer's lifetime to the tree; this
+    /// holds the grammar's table to the same answer.
+    #[test]
+    fn an_error_node_is_named_the_way_the_parser_names_it() {
+        let tree = tree("def foo(\n");
+        let mut stack = vec![tree.root_node()];
+        let mut errors = 0;
+        while let Some(node) = stack.pop() {
+            if node.is_error() {
+                assert!(
+                    (node.kind_id() as usize) >= LANGUAGE.node_kind_count(),
+                    "an id the table carries would not reach the fallback arm"
+                );
+                assert_eq!(node.kind_str(), node.kind(), "kind of {node:?}");
+                errors += 1;
+            }
+            let mut cursor = node.walk();
+            stack.extend(node.children(&mut cursor));
+        }
+        assert!(errors > 0, "the sample has to reach an ERROR node");
+    }
 }

data/src/rules/send_node.rs

@@ -207,7 +207,7 @@ pub(crate) fn string_text<'a>(node: Node<'_>, context: &'a RuleContext<'_>) -> &
     let text = context.source.node_text(node);
     let (Some(open), Some(close)) = (
         node.child(0),
-        node.child(node.child_count().saturating_sub(1) as u32),
+        node.child(node.child_count().saturating_sub(1)),
     ) else {
         return text;
     };
@@ -419,7 +419,7 @@ pub(crate) fn named_children_of<'tree>(
 ) -> Vec<Node<'tree>> {
     match context.named_children(node) {
         Some(children) => children.to_vec(),
-        None => named_children_of(node, context),
+        None => named_children(node),
     }
 }
 

data/src/rules/style/access_modifier_declarations.rs

@@ -142,7 +142,10 @@ impl<'tree> Cop<'_, 'tree> {
         if splat.kind_str() != "splat_argument" {
             return false;
         }
-        let Some(value) = send_node::named_children_of(*splat, self.context).first().copied() else {
+        let Some(value) = send_node::named_children_of(*splat, self.context)
+            .first()
+            .copied()
+        else {
             return false;
         };
         match value.kind_str() {
@@ -384,7 +387,7 @@ impl<'tree> Cop<'_, 'tree> {
         let mut current = node;
         while let Some(parent) = current.parent() {
             if matches!(parent.kind_str(), "class" | "module" | "singleton_class") {
-                let last = u32::try_from(parent.child_count()).ok()?.checked_sub(1)?;
+                let last = parent.child_count().checked_sub(1)?;
                 return parent.child(last).filter(|end| end.kind_str() == "end");
             }
             current = parent;
@@ -459,8 +462,12 @@ impl<'tree> Cop<'_, 'tree> {
     /// code instead and never travels forward.
     fn leading_comments(&self, node: Node<'tree>) -> Vec<Range<usize>> {
         let source = self.context.source;
-        let (line, column) = source.line_column(node.start_byte());
-        if !source.line(line)[..column - 1].trim().is_empty() {
+        let (line, _) = source.line_column(node.start_byte());
+        // The column `line_column` reports counts characters, and the line is sliced by bytes, so
+        // what stands before the node is measured against the line's own start rather than that
+        // column -- a line opening with a multi-byte character would otherwise be sliced inside it.
+        let before = &source.line(line)[..node.start_byte() - source.line_start(line)];
+        if !before.trim().is_empty() {
             return Vec::new();
         }
         let mut comments = Vec::new();

data/src/rules/style/class_and_module_children.rs

@@ -164,7 +164,7 @@ fn nested_correction(
     name: Node<'_>,
 ) -> Option<Vec<Edit>> {
     let keyword = node.child(0)?;
-    let closing = node.child(node.child_count().saturating_sub(1) as u32)?;
+    let closing = node.child(node.child_count().saturating_sub(1))?;
     if closing.kind_str() != "end" {
         return None;
     }
@@ -229,7 +229,7 @@ fn compact_correction(
     }
     let keyword = node.child(0)?;
     let inner_name = inner.field("name")?;
-    let inner_end = inner.child(inner.child_count().saturating_sub(1) as u32)?;
+    let inner_end = inner.child(inner.child_count().saturating_sub(1))?;
     if inner_end.kind_str() != "end" {
         return None;
     }

data/src/rules/style/command_literal.rs

@@ -18,7 +18,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         // `node.heredoc?`: a `<<`CMD`` opens a heredoc, which the grammar spells as its own node.
         let (Some(open), Some(close)) = (
             node.child(0),
-            node.child(node.child_count().saturating_sub(1) as u32),
+            node.child(node.child_count().saturating_sub(1)),
         ) else {
             continue;
         };

data/src/rules/style/concat_array_literals.rs

@@ -128,7 +128,7 @@ fn preferred_method(arrays: &[(ArrayKind, Node<'_>)], context: &RuleContext<'_>)
 /// The `[` and the `]` of an array literal, which the correction drops.
 fn brackets(node: Node<'_>) -> Option<(std::ops::Range<usize>, std::ops::Range<usize>)> {
     let open = node.child(0)?;
-    let close = node.child(node.child_count().checked_sub(1)? as u32)?;
+    let close = node.child(node.child_count().checked_sub(1)?)?;
     (open.id() != close.id()).then(|| (open.byte_range(), close.byte_range()))
 }