sonicop 26.8.111 → 26.8.113

data/src/rules/naming/support.rs

@@ -1,6 +1,5 @@
 //! Name spelling and variable resolution shared by the cops that enforce `EnforcedStyle`.
 
-use std::collections::{HashMap, HashSet};
 use std::ops::Range;
 use std::sync::LazyLock;
 
@@ -9,6 +8,8 @@ use tree_sitter::Node;
 
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_iter;
+use crate::rules::send_node::named_children_of;
 use crate::rules::support::spurious_assignment_list;
 use crate::source::SourceFile;
 
@@ -30,294 +31,11 @@ pub(super) fn valid_name(name: &str, style: &str) -> bool {
     }
 }
 
-/// Which identifiers in one file are variables, and in what role.
-///
-/// Ruby tells a local variable read apart from a receiverless method call by whether the parser
-/// has already seen the name bound in the enclosing scope, and two cops here turn on that
-/// distinction: `Naming/VariableName` reports every `lvar` through `on_lvar`, and
-/// `Naming/ConstantName` excuses `CONST = some_method` while reporting `CONST = some_local`.
-/// tree-sitter spells both as `identifier`, so the scopes have to be replayed to separate them.
-pub(in crate::rules) struct Variables {
-    roles: HashMap<usize, Role>,
-    /// The method names of receiverless calls that also name a local variable in scope.
-    ///
-    /// The grammar reads `collection [0]` as a call handed an array while Ruby reads it as an index
-    /// on the local variable, and only the scope replay can tell the two apart. Nothing upstream
-    /// corresponds to this position, so it is kept apart from the roles a variable handler sees.
-    local_calls: HashSet<usize>,
-}
-
-impl Variables {
-    pub(in crate::rules) fn resolve<'a>(root: Node<'_>, source: &'a SourceFile) -> Self {
-        let mut roles = HashMap::new();
-        let mut local_calls = HashSet::new();
-        let mut scopes: Vec<Scope<'a>> = vec![Scope::new(true)];
-        let mut steps = vec![Step::Visit(root)];
-        while let Some(step) = steps.pop() {
-            match step {
-                Step::Enter(isolated) => scopes.push(Scope::new(isolated)),
-                Step::Leave => {
-                    scopes.pop();
-                }
-                Step::Visit(node) => {
-                    record(node, source, &mut scopes, &mut roles, &mut local_calls);
-                    push_children(node, &mut steps);
-                }
-            }
-        }
-        Self { roles, local_calls }
-    }
-
-    /// Whether a receiverless call's name is a local variable in scope, which is what makes Ruby
-    /// read `collection [0]` as an index rather than as a call handed an array.
-    pub(in crate::rules) fn names_a_local(&self, node: Node<'_>) -> bool {
-        self.local_calls.contains(&node.start_byte())
-    }
-
-    /// Whether RuboCop's variable handlers see this node at all: an assignment target, a
-    /// parameter, or a read that resolved to a local.
-    pub(in crate::rules) fn is_variable(&self, node: Node<'_>) -> bool {
-        self.roles.contains_key(&node.start_byte())
-    }
-
-    /// Whether the parser would build an `lvar` here rather than a receiverless `send`.
-    pub(in crate::rules) fn is_reference(&self, node: Node<'_>) -> bool {
-        self.roles.get(&node.start_byte()) == Some(&Role::Reference)
-    }
-
-    /// Whether the name is being bound: an assignment target or a parameter, which is what
-    /// `on_lvasgn` and `on_arg` between them see.
-    pub(in crate::rules) fn is_definition(&self, node: Node<'_>) -> bool {
-        self.roles.get(&node.start_byte()) == Some(&Role::Definition)
-    }
-}
-
-#[derive(Clone, Copy, PartialEq, Eq)]
-enum Role {
-    /// A name being bound: what `on_lvasgn`, `on_ivasgn`, `on_arg` and the rest of the aliases see.
-    Definition,
-    /// A read of a name bound earlier, which `on_lvar` reports as well.
-    Reference,
-}
-
-struct Scope<'a> {
-    /// Whether the scope hides the names around it, as a `def` or a class body does. Blocks do
-    /// not: they close over the locals of the scope they were written in.
-    isolated: bool,
-    names: HashSet<&'a str>,
-}
-
-impl Scope<'_> {
-    fn new(isolated: bool) -> Self {
-        Self {
-            isolated,
-            names: HashSet::new(),
-        }
-    }
-}
-
-enum Step<'tree> {
-    Visit(Node<'tree>),
-    Enter(bool),
-    Leave,
-}
-
-fn record<'a>(
-    node: Node<'_>,
-    source: &'a SourceFile,
-    scopes: &mut Vec<Scope<'a>>,
-    roles: &mut HashMap<usize, Role>,
-    local_calls: &mut HashSet<usize>,
-) {
-    match node.kind_str() {
-        "identifier" => {
-            let name = source.node_text(node);
-            match position(node) {
-                Position::Binding => {
-                    define(scopes, name);
-                    roles.insert(node.start_byte(), Role::Definition);
-                }
-                Position::Shadow => define(scopes, name),
-                Position::MethodName => {
-                    if resolves(scopes, name) {
-                        local_calls.insert(node.start_byte());
-                    }
-                }
-                Position::Value => {
-                    if resolves(scopes, name) {
-                        roles.insert(node.start_byte(), Role::Reference);
-                    }
-                }
-            }
-        }
-        // Only assignment reaches these; a read of `@foo` has no handler in `Naming/VariableName`.
-        "instance_variable" | "class_variable" | "global_variable" => {
-            if matches!(position(node), Position::Binding) {
-                roles.insert(node.start_byte(), Role::Definition);
-            }
-        }
-        // `in {key:}` binds `key` without giving it an identifier node of its own.
-        "keyword_pattern" if node.field("value").is_none() => {
-            if let Some(key) = node.field("key") {
-                define(scopes, source.node_text(key).trim_end_matches(':'));
-            }
-        }
-        _ => {}
-    }
-}
-
-fn define<'a>(scopes: &mut [Scope<'a>], name: &'a str) {
-    if let Some(scope) = scopes.last_mut() {
-        scope.names.insert(name);
-    }
-}
-
-/// Whether `name` is bound anywhere in the scope chain, stopping at the first scope that hides
-/// its surroundings.
-fn resolves(scopes: &[Scope<'_>], name: &str) -> bool {
-    for scope in scopes.iter().rev() {
-        if scope.names.contains(name) {
-            return true;
-        }
-        if scope.isolated {
-            break;
-        }
-    }
-    false
-}
-
-fn push_children<'tree>(node: Node<'tree>, steps: &mut Vec<Step<'tree>>) {
-    let Some((isolated, outer_fields)) = opened_scope(node.kind_str()) else {
-        let start = steps.len();
-        let mut cursor = node.walk();
-        steps.extend(node.named_children(&mut cursor).map(Step::Visit));
-        steps[start..].reverse();
-        return;
-    };
-    let outer: Vec<Node<'tree>> = outer_fields
-        .iter()
-        .filter_map(|field| node.field(field))
-        .collect();
-    let mut cursor = node.walk();
-    let inner: Vec<Node<'tree>> = node
-        .named_children(&mut cursor)
-        .filter(|child| !outer.iter().any(|node| node.id() == child.id()))
-        .collect();
-    steps.push(Step::Leave);
-    steps.extend(inner.into_iter().rev().map(Step::Visit));
-    steps.push(Step::Enter(isolated));
-    steps.extend(outer.into_iter().rev().map(Step::Visit));
-}
-
-/// The scope a node opens, plus the fields that are still evaluated outside it. A class body
-/// cannot see the locals around it, but the superclass expression written next to it can, and the
-/// same holds for the receiver of `def obj.method`.
-fn opened_scope(kind: &str) -> Option<(bool, &'static [&'static str])> {
-    match kind {
-        "method" => Some((true, &[])),
-        "singleton_method" => Some((true, &["object"])),
-        "class" | "module" => Some((true, &["name", "superclass"])),
-        "singleton_class" => Some((true, &["value"])),
-        "block" | "do_block" | "lambda" => Some((false, &[])),
-        _ => None,
-    }
-}
-
-enum Position {
-    /// A name the assignment or parameter list binds, and that RuboCop reports on.
-    Binding,
-    /// A name bound without RuboCop looking at it. Block-locals arrive as `shadowarg` and pattern
-    /// matches as `match_var`, and `Naming/VariableName` has a handler for neither -- but both
-    /// still make later reads of the name resolve to a local.
-    Shadow,
-    MethodName,
-    Value,
-}
-
-fn position(node: Node<'_>) -> Position {
-    let Some(parent) = node.parent() else {
-        return Position::Value;
-    };
-    match parent.kind_str() {
-        "assignment" | "operator_assignment" => bound_when(node, "left"),
-        "left_assignment_list" if spurious_assignment_list(parent) => {
-            // Only the name the real parser would have assigned to is bound; the items the
-            // grammar swallowed ahead of it are ordinary expressions.
-            if last_named_child(parent).is_some_and(|last| last.id() == node.id()) {
-                Position::Binding
-            } else {
-                Position::Value
-            }
-        }
-        "left_assignment_list" | "destructured_left_assignment" | "rest_assignment" => {
-            Position::Binding
-        }
-        "method_parameters"
-        | "block_parameters"
-        | "lambda_parameters"
-        | "destructured_parameter" => {
-            if field(node) == Some("locals") {
-                Position::Shadow
-            } else {
-                Position::Binding
-            }
-        }
-        "optional_parameter"
-        | "keyword_parameter"
-        | "splat_parameter"
-        | "hash_splat_parameter"
-        | "block_parameter" => bound_when(node, "name"),
-        "for" => bound_when(node, "pattern"),
-        "exception_variable" => Position::Binding,
-        "call" => {
-            if field(node) == Some("method") {
-                Position::MethodName
-            } else {
-                Position::Value
-            }
-        }
-        "method" | "singleton_method" => {
-            if field(node) == Some("name") {
-                Position::MethodName
-            } else {
-                Position::Value
-            }
-        }
-        "setter" | "alias" | "undef" => Position::MethodName,
-        // A pin (`in ^name`) reads an existing local instead of binding a new one.
-        "variable_reference_pattern" => Position::Value,
-        "as_pattern" => shadowed_when(node, "name"),
-        "in_clause" => shadowed_when(node, "pattern"),
-        "array_pattern"
-        | "find_pattern"
-        | "hash_pattern"
-        | "keyword_pattern"
-        | "alternative_pattern" => Position::Shadow,
-        _ => Position::Value,
-    }
-}
-
 pub(super) fn last_named_child(node: Node<'_>) -> Option<Node<'_>> {
     let mut cursor = node.walk();
     node.named_children(&mut cursor).last()
 }
 
-fn bound_when(node: Node<'_>, field_name: &str) -> Position {
-    if field(node) == Some(field_name) {
-        Position::Binding
-    } else {
-        Position::Value
-    }
-}
-
-fn shadowed_when(node: Node<'_>, field_name: &str) -> Position {
-    if field(node) == Some(field_name) {
-        Position::Shadow
-    } else {
-        Position::Value
-    }
-}
-
 /// The field name `node` occupies in its parent. `child_by_field_name` cannot answer this: a
 /// parent may hold several children under the same field, and only the first is reachable that
 /// way.
@@ -374,9 +92,9 @@ pub(super) fn heredocs(context: &RuleContext<'_>) -> Vec<Heredoc> {
         .nodes_of("heredoc_beginning")
         .zip(bodies)
         .filter_map(|(opening, body)| {
-            let mut cursor = body.walk();
-            let terminator = body
-                .named_children(&mut cursor)
+            let _cursor = body.walk();
+            let terminator = named_children_of(body, context)
+                .into_iter()
                 .find(|child| child.kind_str() == "heredoc_end")?;
             let (body_line, _) = context.source.line_column(body.start_byte());
             let (end_line, _) = context.source.line_column(terminator.start_byte());
@@ -574,24 +292,41 @@ fn sexp(node: Node<'_>, source: &SourceFile, indent: usize) -> String {
     }
 }
 
+/// The `defs` a definition is written inside, which upstream reaches through `node.parent` alone.
+/// The grammar hangs a body on a `body_statement`, so the walk passes one to find it.
+fn enclosing_singleton_method<'tree>(node: Node<'tree>) -> Option<Node<'tree>> {
+    let parent = node.parent()?;
+    let parent = match parent.kind_str() {
+        "body_statement" => parent.parent()?,
+        _ => parent,
+    };
+    (parent.kind_str() == "singleton_method").then_some(parent)
+}
+
 /// `class_emitter_method?`: a singleton method may be named after a class defined beside it, as
 /// `def self.Foo` is next to `class Foo`. RuboCop lets that through -- the method emits the class.
-pub(super) fn class_emitter_method(node: Node<'_>, name: &str, source: &SourceFile) -> bool {
+pub(super) fn class_emitter_method<'tree>(
+    node: Node<'tree>,
+    name: &str,
+    context: &'tree RuleContext<'_>,
+) -> bool {
     if node.kind_str() != "singleton_method" {
         return false;
     }
+    let source = context.source;
+    // `node = node.parent while node.parent.defs_type?`, which reaches the enclosing `def
+    // self.included`. Upstream's `defs` holds its body directly; the grammar puts a
+    // `body_statement` between the two, so walking the raw parent stops one level short and the
+    // class beside the *outer* definition is never seen.
     let mut current = node;
-    while let Some(parent) = current
-        .parent()
-        .filter(|p| p.kind_str() == "singleton_method")
-    {
+    while let Some(parent) = enclosing_singleton_method(current) {
         current = parent;
     }
     let Some(parent) = current.parent() else {
         return false;
     };
-    let mut cursor = parent.walk();
-    parent.named_children(&mut cursor).any(|child| {
+    let _cursor = parent.walk();
+    named_children_iter(parent, context).any(|child| {
         child.kind_str() == "class"
             && child
                 .field("name")
@@ -703,7 +438,10 @@ pub(super) fn ruby_regex_to_s(value: &serde_yaml_ng::Value) -> Option<String> {
             let literal = tagged.value.as_str()?;
             split_regexp_literal(literal).unwrap_or((literal, ""))
         }
-        other => (other.as_str()?, ""),
+        // **A plain string is not a `Regexp`.** The message interpolates whatever the configuration
+        // holds, so a `Regex:` written without the `!ruby/regexp` tag prints exactly as written --
+        // only a real `Regexp` goes through `Regexp#to_s`.
+        other => return Some(other.as_str()?.to_owned()),
     };
     let enabled: String = "mix".chars().filter(|flag| flags.contains(*flag)).collect();
     let disabled: String = "mix"
@@ -789,6 +527,27 @@ fn translate_ruby_pattern(pattern: &str) -> String {
     out
 }
 
+/// `forbidden_pattern_regexps`: the `ForbiddenPatterns` entries compiled once.
+///
+/// The entries are plain pattern strings rather than `!ruby/regexp` literals, and they are matched
+/// **anywhere in the name** -- `st_[a-z]` forbids `first_arg`.
+pub(crate) fn forbidden_patterns(context: &RuleContext<'_>) -> Vec<&'static Regex> {
+    forbidden_patterns_named(context, "ForbiddenPatterns")
+}
+
+/// The same for any list of patterns a cop reads under its own key.
+pub(crate) fn forbidden_patterns_named(
+    context: &RuleContext<'_>,
+    key: &str,
+) -> Vec<&'static Regex> {
+    context
+        .setting::<Vec<serde_yaml_ng::Value>>(key)
+        .unwrap_or_default()
+        .iter()
+        .filter_map(ruby_regex)
+        .collect()
+}
+
 #[cfg(test)]
 mod tests {
     use super::valid_name;

data/src/rules/naming/variable_name.rs

@@ -9,7 +9,13 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         .unwrap_or_else(|| "snake_case".to_owned());
     let allowed: Vec<String> = context.setting("AllowedIdentifiers").unwrap_or_default();
     let forbidden: Vec<String> = context.setting("ForbiddenIdentifiers").unwrap_or_default();
-    let variables = context.variable_roles();
+    // `forbidden_name?` is `forbidden_identifier? || forbidden_pattern?`: a name may be forbidden
+    // by an exact spelling or by a pattern it matches anywhere.
+    let patterns = super::support::forbidden_patterns(context);
+    // `valid_name?` is `super || matches_allowed_pattern?(name)`: the allowed patterns excuse a
+    // name from the **enforced style** only. A forbidden name stays forbidden however it is spelt.
+    let allowed_patterns = super::support::forbidden_patterns_named(context, "AllowedPatterns");
+    let variables = context.variable_analysis();
     for node in context.nodes_of_any(&[
         "identifier",
         "instance_variable",
@@ -20,7 +26,12 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             continue;
         }
         let name = context.source.node_text(node);
-        let forbidden_name = forbidden.iter().any(|entry| entry == name);
+        // `SIGILS = '@$'`: both `allowed_identifier?` and `forbidden_identifier?` strip them before
+        // matching, so `AllowedIdentifiers: [first_arg]` covers `@first_arg` too. **The patterns do
+        // not** -- `forbidden_pattern?` is given the name as written.
+        let bare = name.replace(['@', '$'], "");
+        let forbidden_name = forbidden.contains(&bare)
+            || patterns.iter().any(|pattern| pattern.is_match(name));
         // `on_gvasgn` stops at the forbidden names: a global variable's spelling is never held
         // against the enforced style.
         if node.kind_str() == "global_variable" {
@@ -29,12 +40,14 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             }
             continue;
         }
-        if allowed.iter().any(|entry| entry == name) {
+        if allowed.contains(&bare) {
             continue;
         }
         if forbidden_name {
             offenses.push(forbidden_offense(context, node, name));
-        } else if !valid_name(name, &style) {
+        } else if !valid_name(name, &style)
+            && !allowed_patterns.iter().any(|pattern| pattern.is_match(name))
+        {
             offenses.push(context.offense(
                 format!("Use {style} for variable names."),
                 node.byte_range(),

data/src/rules/naming/variable_number.rs

@@ -5,12 +5,13 @@ use regex::Regex;
 use tree_sitter::Node;
 
 use super::support::{
-    PARAMETER_LISTS, ParameterKind, bound_parameters, class_emitter_method,
-    quoted_content, ruby_regex,
+    PARAMETER_LISTS, ParameterKind, bound_parameters, class_emitter_method, quoted_content,
+    ruby_regex,
 };
 use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_iter;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let style: String = context
@@ -44,7 +45,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         }
     }
 
-    let variables = context.variable_roles();
+    let variables = context.variable_analysis();
     for node in context.nodes_of_any(&[
         "identifier",
         "instance_variable",
@@ -89,7 +90,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         }
         if valid_number(&name, &style)
             || patterns.iter().any(|pattern| pattern.is_match(&name))
-            || definition.is_some_and(|node| class_emitter_method(node, &name, context.source))
+            || definition.is_some_and(|node| class_emitter_method(node, &name, context))
         {
             continue;
         }
@@ -160,8 +161,7 @@ fn collect_symbols<'tree>(
             // builds no symbol at all.
             "hash_key_symbol" => {
                 let bare_pattern = node.parent_of(context).is_some_and(|parent| {
-                    parent.kind_str() == "keyword_pattern"
-                        && parent.field("value").is_none()
+                    parent.kind_str() == "keyword_pattern" && parent.field("value").is_none()
                 });
                 if !bare_pattern {
                     push(node.byte_range(), context.source.node_text(node).to_owned());
@@ -179,8 +179,8 @@ fn collect_symbols<'tree>(
             // `alias foo bar` and `undef foo` name methods with symbols the parser invents; only
             // an alias between global variables does not.
             _ => {
-                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 matches!(
                         child.kind_str(),
                         "identifier" | "constant" | "operator" | "setter"
@@ -206,7 +206,6 @@ fn is_quoted_label(node: Node<'_>) -> bool {
         return false;
     }
     let mut cursor = parent.walk();
-    parent
-        .children(&mut cursor)
+    parent.children(&mut cursor)
         .any(|child| child.kind_str() == ":")
 }

data/src/rules/node_ext.rs

@@ -17,7 +17,7 @@ use tree_sitter::{Language, Node};
 
 use crate::rules::RuleContext;
 
-fn language() -> Language {
+pub(in crate::rules) fn language() -> Language {
     tree_sitter_ruby::LANGUAGE.into()
 }
 

data/src/rules/ruby_literal.rs

@@ -9,6 +9,7 @@ use tree_sitter::Node;
 
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_iter;
 
 /// The names a method may be given that are not identifiers, which Ruby writes a symbol of bare.
 const OPERATOR_NAMES: &[&str] = &[
@@ -69,7 +70,8 @@ fn is_bare_identifier(name: &str, method: bool) -> bool {
 pub(crate) fn inspect_string(value: &str) -> String {
     let mut out = String::with_capacity(value.len() + 2);
     out.push('"');
-    for character in value.chars() {
+    let mut characters = value.chars().peekable();
+    while let Some(character) = characters.next() {
         match character {
             '"' => out.push_str("\\\""),
             '\\' => out.push_str("\\\\"),
@@ -82,6 +84,9 @@ pub(crate) fn inspect_string(value: &str) -> String {
             '\u{c}' => out.push_str("\\f"),
             '\u{1b}' => out.push_str("\\e"),
             '\0' => out.push_str("\\0"),
+            // `String#inspect` escapes the `#` that would open an interpolation, so what it
+            // returns stands for the same string when pasted back into double quotes.
+            '#' if matches!(characters.peek(), Some('{' | '@' | '$')) => out.push_str("\\#"),
             other => out.push(other),
         }
     }
@@ -95,8 +100,8 @@ pub(crate) fn string_value(node: Node<'_>, context: &RuleContext<'_>) -> String
     let raw = context.source.node_text(node);
     let verbatim = raw.starts_with('\'') || raw.starts_with("%q") || raw.starts_with(":'");
     let mut value = String::new();
-    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) {
         match child.kind_str() {
             "string_content" if verbatim => {
                 push_verbatim(context.source.node_text(child), &mut value);

data/src/rules/security/compound_hash.rs

@@ -6,6 +6,7 @@ use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
 use crate::rules::send_node::{arguments, is_plain_send, named_children, send_range, symbol_name};
+use crate::rules::send_node::all_children_iter;
 
 const COMBINATOR_IN_HASH_MSG: &str = "Use `[...].hash` instead of combining hash values manually.";
 const MONUPLE_HASH_MSG: &str =
@@ -186,8 +187,8 @@ fn element_count(node: Node<'_>) -> usize {
 
 /// The operator a node was written with, which the grammar leaves as an anonymous token.
 fn operator<'a>(node: Node<'_>, context: &'a RuleContext<'_>) -> Option<&'a str> {
-    let mut cursor = node.walk();
-    node.children(&mut cursor)
+    let _cursor = node.walk();
+    all_children_iter(node, context)
         .find(|child| !child.is_named())
         .map(|child| context.source.node_text(child))
 }

data/src/rules/security/open.rs

@@ -3,10 +3,11 @@ use tree_sitter::Node;
 use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::send_node::{
-    arguments, heredoc_body, is_plain_send, is_string, named_children, string_text,
+    arguments, heredoc_body, is_plain_send, is_string, string_text,
     top_level_constant,
 };
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     for node in context.nodes_of("call") {
@@ -53,7 +54,7 @@ fn safe(node: Node<'_>, context: &RuleContext<'_>) -> bool {
         // with the interpolation itself has no literal part and stays unsafe.
         "string" => safe_argument(&leading_literal(node, context)),
         // `"a" "b"` reaches upstream as a `dstr` of the two literals, so the first one decides.
-        "chained_string" => named_children(node)
+        "chained_string" => named_children_of(node, context)
             .first()
             .is_some_and(|first| safe(*first, context)),
         "heredoc_beginning" => {
@@ -81,7 +82,7 @@ fn safe_argument(argument: &str) -> bool {
 /// every adjacent literal part into one `str`, so escapes and plain runs count together.
 fn leading_literal(node: Node<'_>, context: &RuleContext<'_>) -> String {
     let mut text = String::new();
-    for child in named_children(node) {
+    for child in named_children_of(node, context) {
         if child.kind_str() == "interpolation" {
             break;
         }
@@ -95,7 +96,7 @@ fn leading_literal(node: Node<'_>, context: &RuleContext<'_>) -> String {
 /// when it was opened with `<<~`.
 fn heredoc_leading_text(beginning: Node<'_>, context: &RuleContext<'_>) -> Option<String> {
     let body = heredoc_body(beginning, context)?;
-    let children = named_children(body);
+    let children = named_children_of(body, context);
     let boundary = |kinds: &[&str]| {
         children
             .iter()