sonicop 26.8.105 → 26.8.106

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3bc83b9cca7222947c4ef2dc8c0d18456a627dc98650427dea70f68340df060
-  data.tar.gz: 3567b01985bf947c14427804f847c3530d324eead1b4d56649a18a9e8f69491d
+  metadata.gz: c90ed3a9d03214ba6922d2aecd35c70b28e09791c870f06c22848ef05b336054
+  data.tar.gz: 0557036a886b2023e5151d8b18b1df8bdd66725faf957d19013412a0bc62c6ef
 SHA512:
-  metadata.gz: b10fdaec517230cdfaa915213cf0df5dfab472c65776e0305994f44a49296fb0147c72fd0c1628d66af39052a4985c351e86023f053fbbc50a3363b1f66574f8
-  data.tar.gz: b227a8713413f893f96991859278e05e4c4e4916f6ebc564d01beb0a84e7ed4515002b07c8dc6dc0c1f9ba753e625b8f0d278716894a97a50487db29c9f2adcf
+  metadata.gz: 63191904f82e06d89200c5b81a22a9ad6a4ebcbf07ed86039966605a2d87225d7984a2dfd7a3b0a7b38ca54aaebc1b36518fdb1eeb5dead16318168e3441d692
+  data.tar.gz: deb43652b8dfd0c2c9fac7ed27a1a33fb1097e76bd2d455851ba04d30d2fc6751025fadfdc4012d06f6a45140a983a5686b7bdfc3e5436e5d9ea0e238da26ddd

data/Cargo.lock

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

data/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sonicop"
-version = "26.8.105"
+version = "26.8.106"
 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.105'
+  VERSION = '26.8.106'
 end

data/src/rules/layout/empty_lines_around_arguments.rs

@@ -43,7 +43,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 /// `empty_range_for_starting_point`: the blank line immediately before `start`, when the run of
 /// whitespace reaching back from it spans more than one line break.
 fn empty_range_before(context: &RuleContext<'_>, start: usize) -> Option<Range<usize>> {
-    let begin = final_pos(context.source.text(), start, false, true, true);
+    let begin = final_pos(context.source.text(), start, false, false, true, true);
     let first_line = context.source.line_column(begin).0;
     let last_line = context.source.line_column(start).0;
     (last_line.checked_sub(first_line)? > 1).then(|| context.source.line_range(last_line - 1))

data/src/rules/layout/multiline_block_layout.rs

@@ -35,7 +35,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let mut edits = Vec::new();
         let mut expression_before_body = open.start_byte();
         if let Some(arguments) = arguments.filter(|_| !on_beginning_line) {
-            let end = final_pos(text, arguments.end_byte(), true, false, false);
+            let end = final_pos(text, arguments.end_byte(), true, false, false, false);
             edits.push(Edit {
                 start: open.end_byte(),
                 end,

data/src/rules/layout/redundant_line_break.rs

@@ -230,6 +230,7 @@ fn register(
     let verification = Verification {
         verify_oversized: true,
         fold_string_concatenation: true,
+        ..Default::default()
     };
     let verified = verified_by_reparse(
         context,

data/src/rules/layout/space_around_block_parameters.rs

@@ -96,7 +96,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             let start = argument.start_byte();
             no_space(
                 context,
-                final_pos(text, start, false, true, false)..start.saturating_sub(1),
+                final_pos(text, start, false, false, true, false)..start.saturating_sub(1),
                 "Extra space before",
                 offenses,
             );

data/src/rules/layout/space_before_block_braces.rs

@@ -36,7 +36,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             continue;
         }
 
-        let space_start = final_pos(text, left.start_byte(), false, true, false);
+        let space_start = final_pos(text, left.start_byte(), false, false, true, false);
         let used_space = space_start != left.start_byte();
         let empty = left.end_byte() == right.start_byte();
         let wanted_space = if empty {

data/src/rules/layout/space_before_first_arg.rs

@@ -50,7 +50,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             continue;
         }
 
-        let space = final_pos(text, first.start, false, true, false)..first.start;
+        let space = final_pos(text, first.start, false, false, true, false)..first.start;
         if text[space.clone()].chars().count() == 1 {
             continue;
         }

data/src/rules/lint/locals.rs

@@ -31,6 +31,13 @@ impl<'ctx, 'tree> LocalVariables<'ctx, 'tree> {
         self.context.variable_analysis().is_variable_reference(node)
     }
 
+    /// Whether this `foo()` would read a local variable instead of calling anything once its
+    /// parentheses were gone. The call itself is a call whatever the name holds, so [`Self::is_lvar`]
+    /// says no about every part of it; the question is about the bare name a correction would leave.
+    pub(in crate::rules) fn shadows_a_local(&self, node: Node<'_>) -> bool {
+        self.context.variable_analysis().shadows_a_local(node)
+    }
+
     /// Where each variable in the file is written and where it is read.
     ///
     /// A cop that joins `VariableForce` through `after_leaving_scope` sees the whole table rather

data/src/rules/lint/redundant_cop_disable_directive.rs

@@ -439,12 +439,12 @@ fn trailing_range(source: &SourceFile, ranges: &[Range<usize>], range: &Range<us
 
 /// `range_with_surrounding_space(side: :left, newlines: true)`.
 fn grow_left(source: &SourceFile, range: Range<usize>) -> Range<usize> {
-    final_pos(source.text(), range.start, false, true, false)..range.end
+    final_pos(source.text(), range.start, false, false, true, false)..range.end
 }
 
 /// `range_with_surrounding_space(side: :right)`, with the newline eaten only when asked.
 fn grow_right(source: &SourceFile, range: Range<usize>, newlines: bool) -> Range<usize> {
-    range.start..final_pos(source.text(), range.end, true, newlines, false)
+    range.start..final_pos(source.text(), range.end, true, false, newlines, false)
 }
 
 fn grow_right_spaces_only(source: &SourceFile, range: Range<usize>) -> Range<usize> {

data/src/rules/lint/redundant_cop_enable_directive.rs

@@ -173,7 +173,7 @@ fn register(
             end: final_pos(
                 context.source.text(),
                 directive.range.end,
-                true,
+                true, false,
                 true,
                 false,
             ),

data/src/rules/lint/trailing_comma_in_attribute_declaration.rs

@@ -34,7 +34,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let comma = final_pos(
             context.source.text(),
             arguments[arguments.len() - 2].range().end,
-            true,
+            true, false,
             true,
             false,
         );

data/src/rules/lint/variable_force.rs

@@ -142,6 +142,10 @@ pub(in crate::rules) struct Analysis<'tree> {
     /// local from a receiverless call, and only the analysis knows which one the parser upstream
     /// would have built.
     lvars: HashSet<usize>,
+    /// The `foo()` calls whose name a local variable already holds. The parentheses make these
+    /// calls whatever the name resolves to, so nothing here is an `lvar` -- but writing the same
+    /// name without them would be one, which is the question a cop that drops parentheses asks.
+    shadowed_calls: HashSet<usize>,
 }
 
 impl<'tree> Analysis<'tree> {
@@ -150,6 +154,12 @@ impl<'tree> Analysis<'tree> {
         self.lvars.contains(&node.id())
     }
 
+    /// Whether this `foo()` would stop being a call if its parentheses went away, because a local
+    /// variable of that name is in scope. Only the walk knows what is in scope at a given node.
+    pub(in crate::rules) fn shadows_a_local(&self, node: Node<'_>) -> bool {
+        self.shadowed_calls.contains(&node.id())
+    }
+
     pub(in crate::rules) fn run(root: Node<'tree>, source: &SourceFile) -> Self {
         let mut force = Force {
             source,
@@ -161,6 +171,7 @@ impl<'tree> Analysis<'tree> {
             heredocs: heredoc_bodies(root),
             scanned: HashSet::new(),
             lvars: HashSet::new(),
+            shadowed_calls: HashSet::new(),
         };
         force.push_scope(root, true);
         force.process_children(root);
@@ -169,6 +180,7 @@ impl<'tree> Analysis<'tree> {
             scopes: force.scopes,
             variables: force.variables,
             lvars: force.lvars,
+            shadowed_calls: force.shadowed_calls,
         }
     }
 }
@@ -207,6 +219,7 @@ struct Force<'tree, 'a> {
     /// Nodes already walked in an outer scope, which the scope they sit in must not walk again.
     scanned: HashSet<usize>,
     lvars: HashSet<usize>,
+    shadowed_calls: HashSet<usize>,
 }
 
 // ---------------------------------------------------------------------------
@@ -779,6 +792,9 @@ impl<'tree> Force<'tree, '_> {
         if self.binary_operator_on_a_local(node) {
             return;
         }
+        if self.name_is_taken_by_a_local(node) {
+            self.shadowed_calls.insert(node.id());
+        }
         if let Some(method) = node.field("method")
             && self.text(method) == "binding"
             && opaque_binding_argument(node)
@@ -804,6 +820,24 @@ impl<'tree> Force<'tree, '_> {
         }
     }
 
+    /// Whether `foo()` is written where a local variable already holds the name `foo`.
+    ///
+    /// The empty parentheses make it a call either way, so no `lvar` is built here and the name is
+    /// not a read of the variable. Dropping them would leave a bare name, and that one _is_ the
+    /// variable -- which is why a cop that offers to drop them has to leave this call alone.
+    fn name_is_taken_by_a_local(&self, node: Node<'tree>) -> bool {
+        if node.field("receiver").is_some() {
+            return false;
+        }
+        let (Some(method), Some(arguments)) = (node.field("method"), node.field("arguments"))
+        else {
+            return false;
+        };
+        method.kind_str() == "identifier"
+            && arguments.named_child_count() == 0
+            && self.find_variable(self.text(method)).is_some()
+    }
+
     /// Whether the call is really `local & expr` or `local * expr`. Ruby resolves the ambiguity by
     /// what it has already seen: once the name is a local variable, the `&` is an operator and not
     /// the start of a block-pass argument. tree-sitter has no scope to consult and always reads the

data/src/rules/style/collection_querying.rs

@@ -47,7 +47,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         // `removal_range`: everything from the comparison's own dot or operator, with the blank in
         // front of it.
         let removal =
-            final_pos(context.source.text(), dot.start, false, true, false)..node.end_byte();
+            final_pos(context.source.text(), dot.start, false, false, true, false)..node.end_byte();
         offenses.push(
             context
                 .offense(format!("Use `{replacement}` instead."), range)

data/src/rules/style/combinable_defined.rs

@@ -101,7 +101,7 @@ fn removal(context: &RuleContext<'_>, subject: Node<'_>) -> Option<std::ops::Ran
         term.start_byte()..position
     };
     // `range_with_surrounding_space(side: :right, newlines: false)`.
-    Some(range.start..final_pos(text, range.end, true, false, false))
+    Some(range.start..final_pos(text, range.end, true, false, false, false))
 }
 
 /// `node.parent.and_type?`: `&&` and `and`, which are one node type upstream.

data/src/rules/style/data_inheritance.rs

@@ -39,8 +39,8 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let mut edits = vec![
             // `range_with_surrounding_space(node.loc.keyword, newlines: false)`.
             Edit {
-                start: final_pos(text, keyword.start_byte(), false, false, false),
-                end: final_pos(text, keyword.end_byte(), true, false, false),
+                start: final_pos(text, keyword.start_byte(), false, false, false, false),
+                end: final_pos(text, keyword.end_byte(), true, false, false, false),
                 replacement: String::new(),
                 safe: true,
             },
@@ -65,8 +65,8 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
                 }
                 if let Some(close) = super::conditional::token(block, &["}", "end"]) {
                     edits.push(Edit {
-                        start: final_pos(text, close.start_byte(), false, false, false),
-                        end: final_pos(text, close.end_byte(), true, false, false),
+                        start: final_pos(text, close.start_byte(), false, false, false, false),
+                        end: final_pos(text, close.end_byte(), true, false, false, false),
                         replacement: String::new(),
                         safe: true,
                     });

data/src/rules/style/map_into_array.rs

@@ -93,14 +93,14 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
                     continue;
                 };
                 edits.push(removal(
-                    final_pos(text, close.start_byte(), false, true, false)..close.end_byte(),
+                    final_pos(text, close.start_byte(), false, false, true, false)..close.end_byte(),
                 ));
             }
             // `remove_assignment`: the blank after it goes too, line break included.
             (None, Some(assignment)) => {
-                let end = final_pos(text, assignment.end_byte(), true, true, false);
+                let end = final_pos(text, assignment.end_byte(), true, false, true, false);
                 edits.push(removal(
-                    assignment.start_byte()..final_pos(text, end, true, false, false),
+                    assignment.start_byte()..final_pos(text, end, true, false, false, false),
                 ));
             }
             (None, None) => continue,
@@ -128,7 +128,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             && context.source.node_text(sibling) == variable.name
         {
             edits.push(removal(
-                final_pos(text, sibling.start_byte(), false, true, false)..sibling.end_byte(),
+                final_pos(text, sibling.start_byte(), false, false, true, false)..sibling.end_byte(),
             ));
         }
         edits.push(Edit {

data/src/rules/style/map_to_hash.rs

@@ -40,7 +40,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             continue;
         };
         let dot_source = context.source.node_text(dot);
-        let start = final_pos(context.source.text(), dot.start_byte(), false, true, false);
+        let start = final_pos(context.source.text(), dot.start_byte(), false, false, true, false);
         let mut edits = vec![
             Edit {
                 start,

data/src/rules/style/map_to_set.rs

@@ -34,7 +34,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         };
         // `range_with_surrounding_space(side: :left)`: the conversion goes with the blank in front
         // of it, so a chain written over two lines closes up.
-        let start = final_pos(context.source.text(), dot.start_byte(), false, true, false);
+        let start = final_pos(context.source.text(), dot.start_byte(), false, false, true, false);
         offenses.push(
             context
                 .offense(

data/src/rules/style/method_call_with_args_parentheses.rs

@@ -46,7 +46,7 @@ fn require_parentheses(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             continue;
         };
         let written = super::nodes::children(arguments);
-        if written.is_empty() || is_parenthesized(arguments) {
+        if written.is_empty() || is_parenthesized(node, arguments, context) {
             continue;
         }
         // `args_begin`: the character after the selector, which is the blank before the arguments.
@@ -164,10 +164,23 @@ fn argument_list<'tree>(node: Node<'tree>) -> Option<Node<'tree>> {
 
 /// `parenthesized?`: the parentheses belong to the call rather than to its first argument, which is
 /// what `foo(1)` has and `foo (1)` does not.
-fn is_parenthesized(arguments: Node<'_>) -> bool {
-    arguments
-        .child(0)
-        .is_some_and(|first| !first.is_named() && first.kind_str() == "(")
+///
+/// Upstream settles this while lexing -- a `(` written straight against the selector opens the call
+/// -- so the answer is adjacency, not shape. Reading the shape instead is wrong in one direction:
+/// the grammar here usually gives the call's own parentheses as `(` and `)` tokens of the argument
+/// list, but for some receivers it wraps them in a `parenthesized_statements` node, which then reads
+/// as `foo (1)` and makes a properly parenthesized call look bare.
+///
+/// `expect(x).to receive(:y) do ... end.at_least(:once)` is such a receiver: the `at_least(:once)`
+/// there parses to the wrapped shape while the same call after a simpler receiver does not.
+fn is_parenthesized(node: Node<'_>, arguments: Node<'_>, context: &RuleContext<'_>) -> bool {
+    let Some(selector) = selector_end(node) else {
+        return false;
+    };
+    // The argument list begins where the arguments do, so a `(` of its own is the call's only when
+    // nothing separates it from the selector.
+    arguments.start_byte() == selector
+        && context.source.text().as_bytes().get(selector) == Some(&b'(')
 }
 
 /// `omit_parentheses`.
@@ -195,7 +208,13 @@ fn omit_parentheses(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         |node| omission_edits(*node, context),
         |node| omission_range(*node),
         // 本家の `verified_by_reparse(@pending_omit_offenses)` は追加のオプションを渡さない。
-        crate::rules::support::Verification::default(),
+        // `fold_empty_call_parentheses` は本家の設定ではなく、`foo()` と `foo` を 1 つの
+        // ノードにする本家のパーサに合わせるためのもの。名前を局所変数が持っている呼び出しは
+        // `omits` が先に外している。
+        crate::rules::support::Verification {
+            fold_empty_call_parentheses: true,
+            ..Default::default()
+        },
     );
     verified.extend(with_heredoc);
     verified.sort_by_key(tree_sitter::Node::start_byte);
@@ -243,11 +262,15 @@ impl Omission {
         let Some(arguments) = argument_list(node) else {
             return false;
         };
-        if !is_parenthesized(arguments) {
+        if !is_parenthesized(node, arguments, context) {
             return false;
         }
         let written = super::nodes::children(arguments);
-        !inside_endless_method_def(node, &written, context)
+        // Upstream's reparse settles this one: `foo()` is a call, `foo` is the local variable of
+        // that name, and the two trees do not match. The comparison here cannot tell them apart,
+        // so the candidate never reaches it.
+        !locals.shadows_a_local(node)
+            && !inside_endless_method_def(node, &written, context)
             && !hash_value_omission_needs_parentheses(node, &written, context)
             && !syntax_like_method_call(node, context)
             && !before_constant_resolution(node, context)
@@ -272,7 +295,7 @@ impl Omission {
             || call_in_optional_arguments(node, context)
             || call_in_single_line_inheritance(node, context)
             || (self.multiline && is_multiline(node, arguments, context))
-            || (self.chaining && chained_with_parentheses(node))
+            || (self.chaining && chained_with_parentheses(node, context))
             || assignment_in_condition(node, context)
             || forwards_anonymous_rest_arguments(written)
     }
@@ -488,7 +511,9 @@ fn call_with_ambiguous_arguments(
         return true;
     }
     let _ = arguments;
-    if hash_literal_in_arguments(node, written, context, locals) || ambiguous_range_argument(written) {
+    if hash_literal_in_arguments(node, written, context, locals)
+        || ambiguous_range_argument(written)
+    {
         return true;
     }
     descendants(node, context)
@@ -567,7 +592,7 @@ fn call_in_single_line_inheritance(node: Node<'_>, context: &RuleContext<'_>) ->
 }
 
 /// `allowed_chained_call_with_parentheses?`: the call it hangs off already writes its own.
-fn chained_with_parentheses(node: Node<'_>) -> bool {
+fn chained_with_parentheses(node: Node<'_>, context: &RuleContext<'_>) -> bool {
     let mut current = node;
     loop {
         let Some(previous) = current
@@ -576,7 +601,9 @@ fn chained_with_parentheses(node: Node<'_>) -> bool {
         else {
             return false;
         };
-        if argument_list(previous).is_some_and(is_parenthesized) {
+        if argument_list(previous)
+            .is_some_and(|arguments| is_parenthesized(previous, arguments, context))
+        {
             return true;
         }
         current = previous;
@@ -697,10 +724,7 @@ fn inside_string_interpolation(node: Node<'_>, context: &RuleContext<'_>) -> boo
 
 /// The node's descendants, leaving out the block a call carries: upstream's parser wraps the block
 /// around the call rather than hanging it off it, so a block is never a call's descendant there.
-fn descendants<'tree>(
-    node: Node<'tree>,
-    context: &'tree RuleContext<'_>,
-) -> Vec<Node<'tree>> {
+fn descendants<'tree>(node: Node<'tree>, context: &'tree RuleContext<'_>) -> Vec<Node<'tree>> {
     let mut out = Vec::new();
     let block = node.field("block").map(|block| block.id());
     for child in super::nodes::children(node) {

data/src/rules/style/multiline_in_pattern_then.rs

@@ -38,7 +38,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let start = final_pos(
             context.source.text(),
             keyword.start_byte(),
-            false,
+            false, false,
             false,
             false,
         );

data/src/rules/style/multiline_method_signature.rs

@@ -61,7 +61,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         }
         // `range_with_surrounding_space(arguments_range(node), side: :left)`.
         let arguments_range =
-            support::final_pos(text, first.start_byte(), false, true, false)..last.end_byte();
+            support::final_pos(text, first.start_byte(), false, false, true, false)..last.end_byte();
         // A list that starts on a later line leaves the name alone on the first one.
         if context.source.line_column(arguments_range.start).0 != opening_line {
             let prefix = node.start_byte() + DEF_LENGTH..parameters.start_byte();

data/src/rules/style/nested_parenthesized_calls.rs

@@ -122,12 +122,13 @@ fn reads_as_binary_and(
             .ends_with([' ', '\t', '\n'])
 }
 
-/// Every blank, line continuation and newline before `start`.
+/// `range_with_surrounding_space(first_arg.begin, side: :left, whitespace: true,
+/// continuations: true)`.
+///
+/// The line continuation is the part that matters: walking back over whitespace alone stops at the
+/// `\` and leaves it in the source, so the `(` that replaces the run lands after it and writes
+/// `foo \(bar)` -- which is not Ruby. The shared walk takes the `\` and its line break together,
+/// since a backslash only ends a line when the break follows it.
 fn leading_space(context: &RuleContext<'_>, start: usize) -> usize {
-    let bytes = context.source.text().as_bytes();
-    let mut position = start;
-    while position > 0 && bytes[position - 1].is_ascii_whitespace() {
-        position -= 1;
-    }
-    position
+    crate::rules::support::final_pos(context.source.text(), start, false, true, true, true)
 }

data/src/rules/style/nil_lambda.rs

@@ -38,8 +38,8 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             == context.source.line_column(block.end_byte()).0
         {
             // `range_with_surrounding_space(body.source_range)`.
-            support::final_pos(text, body.start_byte(), false, true, false)
-                ..support::final_pos(text, body.end_byte(), true, true, false)
+            support::final_pos(text, body.start_byte(), false, false, true, false)
+                ..support::final_pos(text, body.end_byte(), true, false, true, false)
         } else {
             // `range_by_whole_lines(body.source_range, include_final_newline: true)`.
             whole_lines(body.byte_range(), context)

data/src/rules/style/operator_method_call.rs

@@ -76,10 +76,10 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             // `ParenthesesCorrector.correct`: the argument's own parentheses go away.
             edits.push(remove(
                 list.start_byte()
-                    ..support::final_pos(text, list.start_byte() + 1, true, false, true),
+                    ..support::final_pos(text, list.start_byte() + 1, true, false, false, true),
             ));
             edits.push(remove(
-                support::final_pos(text, list.end_byte() - 1, false, true, false)..list.end_byte(),
+                support::final_pos(text, list.end_byte() - 1, false, false, true, false)..list.end_byte(),
             ));
             edits.push(insert(selector.end_byte(), " "));
             edits.push(insert(node.start_byte(), "("));

data/src/rules/style/parens.rs

@@ -31,6 +31,11 @@ pub(super) fn correct(context: &RuleContext<'_>, node: Node<'_>) -> Vec<Edit> {
             safe: true,
         },
         Edit {
+            // `remove_close_paren`: `range_with_surrounding_space(side: :left, newlines: newlines)`.
+            // `whitespace` and `continuations` both stay at their default of `false`, so the walk
+            // stops at a `\` that ends the line and leaves it standing. The `continuations: true`
+            // walk belongs to `parens_range`, which is a *different* range that upstream builds
+            // only when a comma would be left stranded -- see `orphaned_comma_start` below.
             start: super::ranges::extended_left(text, close, newlines),
             end: range.end,
             replacement: String::new(),
@@ -72,13 +77,17 @@ fn orphaned_comma_start(context: &RuleContext<'_>, close: usize) -> Option<usize
         return None;
     }
     // `range_with_surrounding_space(side: :left, newlines: true, whitespace: true,
-    // continuations: true)`.
-    let bytes = context.source.text().as_bytes();
-    let mut start = close;
-    while start > 0 && bytes[start - 1].is_ascii_whitespace() {
-        start -= 1;
-    }
-    Some(start)
+    // continuations: true)`. The `continuations` step is the one that matters: a `\` ending the
+    // line would otherwise be left behind once the whitespace around it goes, stranding the
+    // backslash in front of the comma and producing source that does not parse.
+    Some(crate::rules::support::final_pos(
+        context.source.text(),
+        close,
+        false,
+        true,
+        true,
+        true,
+    ))
 }
 
 /// `ternary_condition?(node) && next_char_is_question_mark?(node)`.

data/src/rules/style/redundant_argument.rs

@@ -66,8 +66,8 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let range = if context.source.node_text(arguments).starts_with('(') {
             arguments.byte_range()
         } else {
-            support::final_pos(text, only.start_byte(), false, false, false)
-                ..support::final_pos(text, only.end_byte(), true, false, false)
+            support::final_pos(text, only.start_byte(), false, false, false, false)
+                ..support::final_pos(text, only.end_byte(), true, false, false, false)
         };
         offenses.push(
             context

data/src/rules/support.rs

@@ -16,18 +16,53 @@ pub(crate) fn final_pos(
     text: &str,
     position: usize,
     forward: bool,
+    continuations: bool,
     newlines: bool,
     whitespace: bool,
 ) -> usize {
     let mut position = move_pos(text, position, forward, true, |byte| {
         matches!(byte, b' ' | b'\t')
     });
+    position = move_pos_str(text, position, forward, continuations, "\\\n");
     position = move_pos(text, position, forward, newlines, |byte| byte == b'\n');
+    // `/\s/` upstream, which is Ruby's and takes the vertical tab that Rust's
+    // `is_ascii_whitespace` leaves out.
     move_pos(text, position, forward, whitespace, |byte| {
-        byte.is_ascii_whitespace()
+        matches!(byte, b' ' | b'\t' | b'\n' | b'\r' | 0x0b | 0x0c)
     })
 }
 
+/// `move_pos_str`: the same walk over a fixed run of characters rather than a class.
+///
+/// The one caller wants `\` and a line break, which a class cannot express -- a backslash only ends
+/// the line when the break follows it, and eating it on its own would join two statements.
+fn move_pos_str(
+    text: &str,
+    mut position: usize,
+    forward: bool,
+    enabled: bool,
+    needle: &str,
+) -> usize {
+    if !enabled {
+        return position;
+    }
+    let width = needle.len();
+    loop {
+        let found = match forward {
+            true => text.get(position..position + width) == Some(needle),
+            false => position >= width && text.get(position - width..position) == Some(needle),
+        };
+        if !found {
+            return position;
+        }
+        position = if forward {
+            position + width
+        } else {
+            position - width
+        };
+    }
+}
+
 fn move_pos(
     text: &str,
     mut position: usize,
@@ -173,6 +208,16 @@ pub(crate) struct Verification {
     /// without changing the string it builds. Folding every concatenation to a canonical form is
     /// what lets the two compare equal.
     pub(crate) fold_string_concatenation: bool,
+    /// `foo()` and `foo` are one and the same node upstream: the parser builds nothing for an empty
+    /// argument list, and a receiverless call carrying only its name is spelled as a bare name.
+    /// The grammar here keeps the two apart -- `call` with an `argument_list` that has no children
+    /// on one side, a lone `identifier` on the other -- so a correction that drops nothing but a
+    /// pair of empty parentheses never compares equal without this.
+    ///
+    /// Upstream's parser tells `(send nil :foo)` from `(lvar :foo)` by remembering what it has seen
+    /// assigned, which a tree already built cannot. The caller that turns this on has to keep the
+    /// calls whose name a local variable holds out on its own.
+    pub(crate) fold_empty_call_parentheses: bool,
 }
 
 /// `ReparsedEquivalence#verified_by_reparse`: the items whose corrections leave a tree equal to the
@@ -321,12 +366,18 @@ fn normalized(node: Node<'_>, text: &str, verification: Verification) -> Sexp {
         return literal;
     }
     let mut children: Vec<Sexp> = Vec::new();
+    let mut dropped_parentheses = false;
     let mut cursor = node.walk();
     for child in node.named_children(&mut cursor) {
         // Comments are invisible to the tree upstream compares.
         if child.kind_str() == "comment" {
             continue;
         }
+        // So is the empty argument list of `foo()`, which upstream's parser never builds.
+        if verification.fold_empty_call_parentheses && empty_argument_list(child) {
+            dropped_parentheses = true;
+            continue;
+        }
         let normalized = normalized(child, text, verification);
         // `splice_nested_sequences`: `x; (a; b)` and `x; a; b` are the same statement list.
         match SEQUENCES.contains(&node.kind_str()) && normalized.label == BEGIN {
@@ -346,6 +397,9 @@ fn normalized(node: Node<'_>, text: &str, verification: Verification) -> Sexp {
             children,
         };
     }
+    if dropped_parentheses && let Some(bare) = written_without_parentheses(node, &mut children) {
+        return bare;
+    }
     if !verification.fold_string_concatenation {
         let label = label_of(node, text, children.is_empty());
         return rotate_same_operator(Sexp { label, children });
@@ -358,6 +412,39 @@ fn normalized(node: Node<'_>, text: &str, verification: Verification) -> Sexp {
     fold_string_concatenation(rotate_same_operator(Sexp { label, children }))
 }
 
+/// Whether the node is the `()` of `foo()`, which upstream's parser leaves no node behind for.
+fn empty_argument_list(node: Node<'_>) -> bool {
+    node.kind_str() == "argument_list" && node.named_child_count() == 0
+}
+
+/// The label a bare `yield` carries, which is a leaf holding nothing but the keyword.
+const BARE_YIELD: &str = "yield yield";
+
+/// What a call whose empty parentheses were just dropped reads as, when dropping them leaves the
+/// spelling the source would have used without them.
+///
+/// `foo()` and `foo` reach upstream as one node, and so do `yield()` and `yield`. Here the first of
+/// each pair is a parent with an `argument_list` under it and the second is written with no node in
+/// between at all -- a lone `identifier`, a childless `yield` -- so the two only compare equal once
+/// the first is put in the shape of the second. A receiver or a block means something is still
+/// written around the name and the spellings stay apart.
+fn written_without_parentheses(node: Node<'_>, children: &mut Vec<Sexp>) -> Option<Sexp> {
+    match node.kind_str() {
+        "yield" if children.is_empty() => Some(Sexp {
+            label: BARE_YIELD.to_owned(),
+            children: Vec::new(),
+        }),
+        "call"
+            if children.len() == 1
+                && node.field("receiver").is_none()
+                && node.field("block").is_none() =>
+        {
+            children.pop()
+        }
+        _ => None,
+    }
+}
+
 /// The kinds whose contents upstream's parser reads as whitespace-separated words, one node each.
 const WORD_ARRAYS: &[&str] = &["string_array", "symbol_array"];
 
@@ -386,7 +473,7 @@ fn word_array(node: Node<'_>, text: &str) -> Option<Sexp> {
             }
             continue;
         }
-        if character.is_ascii_whitespace() {
+        if separates_words(character) {
             if !word.is_empty() {
                 words.push(word_leaf(std::mem::take(&mut word)));
             }
@@ -403,6 +490,15 @@ fn word_array(node: Node<'_>, text: &str) -> Option<Sexp> {
     })
 }
 
+/// Whether the character ends a word of a `%w` or `%i` literal.
+///
+/// Ruby's lexer asks `ISSPACE`, which is the six ASCII spacing characters and nothing else -- a
+/// no-break space is part of the word. `char::is_ascii_whitespace` is the same set minus the
+/// vertical tab, so spelling the six out is what matches (measured: `%w[a\vb]` is two words).
+fn separates_words(character: char) -> bool {
+    matches!(character, ' ' | '\t' | '\n' | '\r' | '\u{b}' | '\u{c}')
+}
+
 fn word_leaf(text: String) -> Sexp {
     Sexp {
         label: format!("word {text}"),

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sonicop
 version: !ruby/object:Gem::Version
-  version: 26.8.105
+  version: 26.8.106
 platform: ruby
 authors:
 - Yohei