sonicop 26.8.104 → 26.8.105

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 267d186a55418ccb97a890bcea5da9eda428dd6567ae4282b61755779783d6e2
-  data.tar.gz: baa0dfdcff20c0a1888222298deab0fd2af37fd9fcd25ef8beb2871bb89083fc
+  metadata.gz: f3bc83b9cca7222947c4ef2dc8c0d18456a627dc98650427dea70f68340df060
+  data.tar.gz: 3567b01985bf947c14427804f847c3530d324eead1b4d56649a18a9e8f69491d
 SHA512:
-  metadata.gz: 1f983d82729522d8a18d1155a4d9b1b6d020b837e987abc2d5bbf14558587997f1abf8808e69ae1e36132b6d15f8cac0d0cf440f116cb9280b98397d7b8f3c03
-  data.tar.gz: 2ffd0dd8db704b600fda62f08c1f61455fc36310f1adc33d4ae6f1bc1b2a53998c8034103a871e4e9e2b239f798a181a66982dafbda3d9b6ae0f5b74845d0887
+  metadata.gz: b10fdaec517230cdfaa915213cf0df5dfab472c65776e0305994f44a49296fb0147c72fd0c1628d66af39052a4985c351e86023f053fbbc50a3363b1f66574f8
+  data.tar.gz: b227a8713413f893f96991859278e05e4c4e4916f6ebc564d01beb0a84e7ed4515002b07c8dc6dc0c1f9ba753e625b8f0d278716894a97a50487db29c9f2adcf

data/Cargo.lock

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

data/Cargo.toml

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

data/README.ja.md

@@ -119,7 +119,7 @@ Mastodon（15,286 件）で、過剰も不足もメタデータ差もありま
 Mastodon でバイト単位に一致します。この 2 つは死守ラインとして扱い、バイト一致が崩れた場合は
 既知差分ではなく退行として直します。
 
-コマンド、コーパスごとの数値、この種の計測が誤った結論を導く 2 つの罠は
+コマンド、この数値を測ったコーパスのコミット、この種の計測が誤った結論を導く 2 つの罠は
 [CONFORMANCE.md](CONFORMANCE.md) にまとめています。
 
 ### 性能

data/README.md

@@ -129,8 +129,8 @@ parser recovers from an error and emits diagnostics a tree-sitter parse cannot r
 Autocorrect is byte-identical on RuboCop's own tree and on Mastodon, the two corpora held as a hard
 line: a change that breaks byte equality there is a regression, not a new known divergence.
 
-See [CONFORMANCE.md](CONFORMANCE.md) for the commands, the per-corpus numbers, and the two ways a
-measurement of this kind can mislead you.
+See [CONFORMANCE.md](CONFORMANCE.md) for the commands, the corpus commits these counts were
+measured at, and the two ways a measurement of this kind can mislead you.
 
 ### Performance
 

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.104'
+  VERSION = '26.8.105'
 end

data/src/directives.rs

@@ -36,8 +36,28 @@ impl DirectiveState {
         source: &SourceFile,
         comment_ranges: &[Range<usize>],
         prevents_directive_disabling: bool,
+    ) -> Self {
+        Self::parse_opting_in(source, comment_ranges, prevents_directive_disabling, &[])
+    }
+
+    /// The same, plus the cops the configuration switched off that this file asks back with an
+    /// `enable` directive.
+    ///
+    /// `CommentConfig#inject_disabled_cops_directives` gives every cop the configuration switched
+    /// off a disable written at `-Float::INFINITY`, so a real `# rubocop:enable Foo` closes that
+    /// range and Foo reports from there down. Only the cops the file names are seeded here: the
+    /// snapshot is cloned for every line, and the 200-odd cops RuboCop ships switched off would
+    /// make that clone the cost of the run.
+    pub fn parse_opting_in(
+        source: &SourceFile,
+        comment_ranges: &[Range<usize>],
+        prevents_directive_disabling: bool,
+        disabled_by_config: &[&str],
     ) -> Self {
         let mut current = Snapshot::default();
+        for cop in disabled_by_config {
+            current.cops.insert((*cop).to_owned(), None);
+        }
         let mut stack = Vec::new();
         let mut line_states = Vec::with_capacity(source.line_count());
         // Where the first comment written on each line begins, as an offset into that line. Only
@@ -157,6 +177,34 @@ impl DirectiveState {
     }
 }
 
+/// `CommentConfig#opt_in_cops`: the cops an `enable` directive in the file names.
+///
+/// This is what can put a cop the configuration switched off back on duty -- upstream keeps the
+/// registry on standby and mobilizes one when a file asks for it. `enable all` names none of them,
+/// and a `push` directive is not an `enable`, so neither opts a cop in.
+pub fn opted_in_cops(source: &SourceFile, comment_ranges: &[Range<usize>]) -> HashSet<String> {
+    let mut names = HashSet::new();
+    // `@no_directives`: upstream skips the whole analysis, injection included, for a file that does
+    // not mention RuboCop at all. Most files do not, and this is the only reason the scan can be
+    // afforded on every one of them.
+    if !source.text().contains("rubocop") {
+        return names;
+    }
+    for range in comment_ranges {
+        let (line_number, _) = source.line_column(range.start);
+        let column = range.start - source.line_start(line_number);
+        let line = source.line(line_number);
+        let Some(directive) = parse_directive(line, column) else {
+            continue;
+        };
+        if !matches!(directive.action, Action::Enable) {
+            continue;
+        }
+        names.extend(directive.cops.iter().filter(|cop| *cop != "all").cloned());
+    }
+    names
+}
+
 fn apply_disable(state: &mut Snapshot, cops: &[String], reason: Option<String>) {
     if cops.iter().any(|cop| cop == "all") {
         state.all = true;

data/src/engine.rs

@@ -114,6 +114,11 @@ impl Selection {
 /// `Exclude` reads the path being inspected, so it is all that stays per-file.
 pub(crate) struct RulePlan {
     entries: Vec<PlannedRule>,
+    /// The cops the configuration switched off that a file could ask back with an `enable`
+    /// directive. Upstream keeps the whole registry on standby for exactly this and mobilizes one
+    /// when `CommentConfig#opt_in_cops` names it, so the selection is settled here but the decision
+    /// is per file.
+    standby: Vec<PlannedRule>,
     /// What the cop that reads directives needs to know about the cops that exist. Built once per
     /// configuration because it depends on nothing in the file, and only when that cop will run.
     directive_registry: Option<CopRegistry>,
@@ -130,29 +135,36 @@ struct PlannedRule {
 
 impl RulePlan {
     pub(crate) fn build(config: &Config, selection: &Selection) -> Self {
-        let entries = rules()
-            .enumerate()
-            .filter(|(_, rule)| {
-                let enabled = config.rule_enabled_with_pending(
-                    rule.name,
-                    selection.enable_pending,
-                    selection.disable_pending,
-                );
-                selection.includes(rule.name, enabled, config.rule_safe(rule.name))
-            })
-            .map(|(index, rule)| PlannedRule {
-                rule,
-                index,
-                severity: config
-                    .cop_value::<String>(rule.name, "Severity")
-                    .and_then(|value| Severity::parse(&value))
-                    .unwrap_or(rule.severity),
-                // `AutocorrectLogic#safe_autocorrect?` is both halves: a cop whose analysis is
-                // unsafe cannot have a safe correction either, however `SafeAutoCorrect` was left.
-                safe_autocorrect: config.rule_safe(rule.name)
-                    && config.rule_safe_autocorrect(rule.name),
-            })
-            .collect::<Vec<_>>();
+        let planned = |index: usize, rule: &'static Rule| PlannedRule {
+            rule,
+            index,
+            severity: config
+                .cop_value::<String>(rule.name, "Severity")
+                .and_then(|value| Severity::parse(&value))
+                .unwrap_or(rule.severity),
+            // `AutocorrectLogic#safe_autocorrect?` is both halves: a cop whose analysis is
+            // unsafe cannot have a safe correction either, however `SafeAutoCorrect` was left.
+            safe_autocorrect: config.rule_safe(rule.name)
+                && config.rule_safe_autocorrect(rule.name),
+        };
+        let mut entries = Vec::new();
+        let mut standby = Vec::new();
+        for (index, rule) in rules().enumerate() {
+            let safe = config.rule_safe(rule.name);
+            let enabled = config.rule_enabled_with_pending(
+                rule.name,
+                selection.enable_pending,
+                selection.disable_pending,
+            );
+            if selection.includes(rule.name, enabled, safe) {
+                entries.push(planned(index, rule));
+            } else if !enabled && selection.includes(rule.name, true, safe) {
+                // Only the configuration stands in the way, which is what an `enable` directive can
+                // undo. A cop the run itself left out (`--only`, `--except`, the safety filters)
+                // stays out however the file is written.
+                standby.push(planned(index, rule));
+            }
+        }
         let directive_registry = (selection.checks_redundant_directives()
             && entries
                 .iter()
@@ -160,6 +172,7 @@ impl RulePlan {
         .then(|| CopRegistry::new(config, selection));
         Self {
             entries,
+            standby,
             directive_registry,
         }
     }
@@ -229,12 +242,27 @@ fn inspect_planned(
     let ast = crate::profile::phase(crate::profile::Phase::Index, || {
         AstIndex::new(tree.root_node())
     });
+    // `opted_in_standby_cops`: a cop the configuration switched off is put back on duty for this
+    // file when an `enable` directive names it. The names are read once and used twice -- to pick
+    // the cops out of the plan's standby list, and to seed the directive state so that only what
+    // the `enable` opens is reported.
+    let opted_in: Vec<&PlannedRule> = if plan.standby.is_empty() {
+        Vec::new()
+    } else {
+        let names = crate::directives::opted_in_cops(&source, ast.comment_ranges());
+        plan.standby
+            .iter()
+            .filter(|planned| names.contains(planned.rule.name))
+            .collect()
+    };
+    let disabled_by_config: Vec<&str> = opted_in.iter().map(|planned| planned.rule.name).collect();
     let directives = crate::profile::phase(crate::profile::Phase::Directives, || {
         (!selection.ignore_disable_comments).then(|| {
-            DirectiveState::parse_for(
+            DirectiveState::parse_opting_in(
                 &source,
                 ast.comment_ranges(),
                 config.prevents_directive_disabling(),
+                &disabled_by_config,
             )
         })
     });
@@ -276,8 +304,11 @@ fn inspect_planned(
         syntax_rule,
         syntax_severity,
         selection.correcting,
-    );
-    for planned in &plan.entries {
+    )
+    // `registry.disabled_names(config)`: whether the run switches any cop off at all, which is
+    // what an `# rubocop:enable all` has to undo. The standby list is that set already.
+    .with_disabled_cops(!plan.standby.is_empty());
+    for planned in plan.entries.iter().chain(opted_in.iter().copied()) {
         let rule = planned.rule;
         // `Cop::Base#relevant_file?`: a cop applies to a file its own `Include` reaches and its own
         // `Exclude` does not, which is how a `Bundler` cop stays off everything but a Gemfile.
@@ -1295,6 +1326,27 @@ pub fn corrected_text(
 
 const MAX_CORRECTION_PASSES: usize = 200;
 
+/// What a pass's text is remembered by, so that the loop can tell it has come round again.
+///
+/// `Runner#check_for_infinite_loop` keeps `processed_source.checksum` rather than the text, and the
+/// difference shows on a file a cop keeps adding to. `Regexp.new("a\\d]b")` grows about 1.5x per
+/// pass under `Lint/UnescapedBracketInRegexp`, measured identical to upstream pass for pass, so
+/// holding every pass costs the sum of that series -- roughly three times the current text -- and
+/// comparing against every pass re-reads all of it. Neither form bounds the growth: that is
+/// upstream's defect, reproduced here rather than fixed.
+///
+/// The length rides along with the hash because it is free and makes a collision take two
+/// coincidences instead of one. A collision would report a loop that is not there, which is a
+/// worse failure than the one being avoided.
+type SourceDigest = (u64, usize);
+
+fn digest(text: &str) -> SourceDigest {
+    use std::hash::{Hash, Hasher};
+    let mut hasher = std::collections::hash_map::DefaultHasher::new();
+    text.hash(&mut hasher);
+    (hasher.finish(), text.len())
+}
+
 type OffenseKey = (usize, usize, &'static str, String, Severity);
 
 fn offense_key(offense: &Offense, source: &SourceFile) -> OffenseKey {
@@ -1448,7 +1500,7 @@ pub fn correct_file(
 
     let path = report.path.clone();
     let mut log = CorrectionLog::default();
-    let mut sources = vec![text.clone()];
+    let mut sources = vec![digest(&text)];
     let mut rewritten = false;
     // Every pass re-inspects the same file under the same configuration, so the plan is resolved
     // once for the whole fixed-point loop.
@@ -1480,7 +1532,8 @@ pub fn correct_file(
 
         // Re-producing a source seen before means the passes are trading edits back and forth; the
         // repeat tells us which pass the cycle closed on.
-        let repeated = sources.iter().position(|source| *source == corrected);
+        let corrected_digest = digest(&corrected);
+        let repeated = sources.iter().position(|seen| *seen == corrected_digest);
         if pass == MAX_CORRECTION_PASSES || repeated.is_some() {
             let loop_start = repeated.unwrap_or_else(|| log.cops_by_pass.len().saturating_sub(1));
             let root_cause = log.root_cause(loop_start);
@@ -1497,7 +1550,7 @@ pub fn correct_file(
             });
         }
 
-        sources.push(corrected.clone());
+        sources.push(corrected_digest);
         text = corrected;
         report = inspect_planned(
             path.clone(),
@@ -1524,7 +1577,7 @@ pub fn correct_until_stable(
     }
 }
 
-/// The bytes to write back for corrected source, in the encoding the file declares for itself.
+/// The bytes to write back for corrected source, in the encoding the file was read in.
 ///
 /// This is the one place Sonicop knowingly departs from RuboCop. RuboCop's runner ends in a plain
 /// `File.write`, so a corrected Shift_JIS file comes back out as UTF-8 while its magic comment still
@@ -1532,9 +1585,17 @@ pub fn correct_until_stable(
 /// data loss on purpose, which is further than drop-in compatibility reaches. The divergence is
 /// recorded in `tests/conformance/known_divergences.yml`.
 ///
+/// That protection only applies to a file the declaration was actually needed for.
+/// [`decoded_source`] reaches for the declared encoding only when the bytes are not valid UTF-8, so
+/// a UTF-8 file naming some other encoding was read as UTF-8 and has to go back out as UTF-8 --
+/// `decoded_as_declared` says which happened, and is only asked once a declaration is found.
+/// Encoding such a file to the label it names rewrites bytes no cop asked to change: rails'
+/// `1_currencies_have_symbols.rb` declares `ISO-8859-15` and holds a UTF-8 `€`, and turning those
+/// three bytes into `\xa4` changes what the program says as surely as editing the literal would.
+///
 /// `Err` when the correction cannot be represented in that encoding, so the caller leaves the file
 /// alone rather than writing a lossy approximation.
-fn output_bytes(contents: &str) -> Result<Vec<u8>> {
+fn output_bytes(contents: &str, decoded_as_declared: impl FnOnce() -> bool) -> Result<Vec<u8>> {
     let Some(label) = encoding_declaration(contents) else {
         return Ok(contents.as_bytes().to_vec());
     };
@@ -1548,7 +1609,7 @@ fn output_bytes(contents: &str) -> Result<Vec<u8>> {
     let Some(encoding) = encoding_for_ruby_label(&label) else {
         return Ok(contents.as_bytes().to_vec());
     };
-    if encoding == encoding_rs::UTF_8 {
+    if encoding == encoding_rs::UTF_8 || !decoded_as_declared() {
         return Ok(contents.as_bytes().to_vec());
     }
     let (bytes, _, unmappable) = encoding.encode(contents);
@@ -1561,8 +1622,11 @@ fn output_bytes(contents: &str) -> Result<Vec<u8>> {
 }
 
 pub fn write_corrected(path: &Path, contents: &str) -> Result<()> {
-    let bytes = output_bytes(contents)
-        .with_context(|| format!("refusing to rewrite {}", path.display()))?;
+    // The file on disk is still the one that was read: the loop corrects in memory and writes once.
+    let bytes = output_bytes(contents, || {
+        fs::read(path).is_ok_and(|bytes| String::from_utf8(bytes).is_err())
+    })
+    .with_context(|| format!("refusing to rewrite {}", path.display()))?;
     let parent = path.parent().unwrap_or(Path::new("."));
     let permissions = fs::metadata(path)
         .ok()
@@ -2075,7 +2139,7 @@ mod tests {
         // RuboCop would write UTF-8 here and leave the file claiming cp932, which no longer loads.
         let corrected = "# encoding: cp932\nx = '\u{65e5}\u{672c}'\n";
 
-        let bytes = output_bytes(corrected).unwrap();
+        let bytes = output_bytes(corrected, || true).unwrap();
 
         assert!(bytes.ends_with(b"x = '\x93\xfa\x96\x7b'\n"));
     }
@@ -2086,7 +2150,19 @@ mod tests {
         // very text the correction was meant to leave alone.
         let corrected = "# encoding: cp932\nx = '\u{1f363}'\n";
 
-        assert!(output_bytes(corrected).is_err());
+        assert!(output_bytes(corrected, || true).is_err());
+    }
+
+    #[test]
+    fn a_utf8_file_that_names_another_encoding_goes_back_out_unchanged() {
+        // rails' `1_currencies_have_symbols.rb`: the comment says ISO-8859-15, the bytes are UTF-8,
+        // and `decoded_source` read it as UTF-8. Encoding the `€` to `\xa4` on the way out would
+        // turn a three-character string into a one-character one -- a change no cop asked for.
+        let corrected = "# coding: ISO-8859-15\nx = '\u{20ac}'\n";
+
+        let bytes = output_bytes(corrected, || false).unwrap();
+
+        assert_eq!(bytes, corrected.as_bytes());
     }
 
     #[test]

data/src/rules/layout/def_end_alignment.rs

@@ -34,27 +34,28 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             }
             // `private def foo`: the modifier and the definition are one line, and the `end` is
             // measured against whichever of the two the style names.
+            //
+            // Every other call falls through: the walk has to keep descending, since a call is
+            // what a block hangs off and a definition written inside one is still a definition.
             "call" => {
-                let Some(definition) = def_modifier(node) else {
-                    continue;
-                };
-                let Some(keyword) = definition.child(0) else {
-                    continue;
-                };
-                let (base, column) = match align_with_def {
-                    true => (
-                        keyword.byte_range(),
-                        character_column(context, definition.start_byte()),
-                    ),
-                    false => (
-                        node.start_byte()..keyword.end_byte(),
-                        character_column(context, node.start_byte()),
-                    ),
-                };
-                if let Some(offense) = check_definition(context, definition, base, column) {
-                    offenses.push(offense);
+                if let Some(definition) = def_modifier(node)
+                    && let Some(keyword) = definition.child(0)
+                {
+                    let (base, column) = match align_with_def {
+                        true => (
+                            keyword.byte_range(),
+                            character_column(context, definition.start_byte()),
+                        ),
+                        false => (
+                            node.start_byte()..keyword.end_byte(),
+                            character_column(context, node.start_byte()),
+                        ),
+                    };
+                    if let Some(offense) = check_definition(context, definition, base, column) {
+                        offenses.push(offense);
+                    }
+                    ignored.insert(definition.id());
                 }
-                ignored.insert(definition.id());
             }
             _ => {}
         }

data/src/rules/lint/assignment_in_condition.rs

@@ -179,8 +179,12 @@ fn traverse(
                     MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED
                 };
                 let offense = context.offense(message, operator.byte_range());
-                offenses.push(match correction(context, node, allow_safe) {
-                    Some(edit) => offense.corrected_by(edit),
+                offenses.push(match correction(allow_safe, node) {
+                    // `corrector.wrap(asgn_node, '(', ')')` is one action over the assignment, so
+                    // both insertions have to hang off that range rather than off the operator.
+                    Some(edits) => offense
+                        .corrected_by_all(edits)
+                        .corrections_anchored_at(node.byte_range()),
                     None => offense,
                 });
             }
@@ -198,7 +202,12 @@ fn traverse(
 /// it is not what the condition tests.
 fn discarded(node: Node<'_>) -> bool {
     node.parent()
-        .filter(|parent| matches!(parent.kind_str(), "parenthesized_statements" | "interpolation"))
+        .filter(|parent| {
+            matches!(
+                parent.kind_str(),
+                "parenthesized_statements" | "interpolation"
+            )
+        })
         .is_some_and(|parent| statements(parent).len() > 1)
 }
 
@@ -207,28 +216,47 @@ fn discarded(node: Node<'_>) -> bool {
 fn statements(node: Node<'_>) -> Vec<Node<'_>> {
     let mut cursor = node.walk();
     node.named_children(&mut cursor)
-        .filter(|child| !matches!(child.kind_str(), "empty_statement" | "comment" | "heredoc_body"))
+        .filter(|child| {
+            !matches!(
+                child.kind_str(),
+                "empty_statement" | "comment" | "heredoc_body"
+            )
+        })
         .collect()
 }
 
 /// The `=` the offense is reported at, which is `loc.operator` upstream.
 fn assignment_operator<'tree>(node: Node<'tree>) -> Option<Node<'tree>> {
     let mut cursor = node.walk();
-    node.children(&mut cursor).find(|child| child.kind_str() == "=")
+    node.children(&mut cursor)
+        .find(|child| child.kind_str() == "=")
 }
 
 /// Wrapping the assignment in parentheses is the one correction: it says the assignment was meant.
 /// With `AllowSafeAssignment: false` that is no longer an answer, and upstream leaves the
 /// corrector empty.
-fn correction(context: &RuleContext<'_>, node: Node<'_>, allow_safe: bool) -> Option<Edit> {
+/// `corrector.wrap` is two insertions at the ends of the range, not a replacement of it. Rewriting
+/// the whole assignment instead hands back the text between the parentheses verbatim, and that text
+/// is everything the assignment spans: an assignment written over several lines then swallows every
+/// other correction inside it. `Layout/IndentationConsistency` shifting those lines sideways in the
+/// same pass loses the shift, and the lines are left where they were.
+fn correction(allow_safe: bool, node: Node<'_>) -> Option<Vec<Edit>> {
     if !allow_safe {
         return None;
     }
     let range: Range<usize> = node.byte_range();
-    Some(Edit {
-        start: range.start,
-        end: range.end,
-        replacement: format!("({})", context.source.node_text(node)),
-        safe: true,
-    })
+    Some(vec![
+        Edit {
+            start: range.start,
+            end: range.start,
+            replacement: "(".to_owned(),
+            safe: true,
+        },
+        Edit {
+            start: range.end,
+            end: range.end,
+            replacement: ")".to_owned(),
+            safe: true,
+        },
+    ])
 }

data/src/rules/lint/missing_cop_enable_directive.rs

@@ -45,8 +45,18 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     }
     for index in open {
         let directive = &parsed[index];
+        // `acceptable_range?`: a cop the configuration switched off is not expected to be
+        // re-enabled, so the range it leaves open to the end of the file is acceptable. Upstream
+        // reads that off `registry.enabled?`, which is the configuration and nothing else -- a cop
+        // an `enable` directive put back on duty for this file still counts as switched off here.
+        // The ranges are kept per cop upstream, so a directive naming one switched off and one left
+        // on is reported under the one left on.
         // `message` names the first cop of the range, which for a department is the department.
-        let Some(name) = directive.names.first() else {
+        let Some(name) = directive
+            .names
+            .iter()
+            .find(|name| is_department(name) || context.cop_enabled(name))
+        else {
             continue;
         };
         let kind = if is_department(name) {

data/src/rules/lint/parentheses_as_grouped_expression.rs

@@ -2,8 +2,8 @@ use tree_sitter::Node;
 
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
-use crate::rules::send_node::arguments;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::arguments;
 
 /// `OPERATOR_METHODS`, which are written with a space on either side by convention.
 const OPERATOR_METHODS: [&str; 29] = [

data/src/rules/lint/redundant_cop_enable_directive.rs

@@ -10,7 +10,14 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     if !context.source.text().contains("enable") {
         return;
     }
-    let mut disabled = Counters::default();
+    let mut disabled = Counters {
+        // `inject_disabled_cops_directives` gives every cop the configuration switched off an
+        // outstanding disable, so an `enable all` always has one of them to undo. Only whether the
+        // set is empty matters, and the run's selection decides that as much as the configuration:
+        // `--only Foo` leaves a registry of one enabled cop and nothing to undo.
+        config_pool: context.run_disables_a_cop(),
+        ..Counters::default()
+    };
     let parsed = directives(context);
     // `registry.disabled_names(config)`: an `enable` of a cop the configuration switched off has
     // something to undo, so it starts out counted as disabled.
@@ -48,6 +55,10 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 struct Counters {
     blanket: usize,
     named: HashMap<String, i64>,
+    /// Whether the cops the configuration switched off still have their injected disable
+    /// outstanding. `handle_enable_all` lowers every positive counter, so the first `enable all`
+    /// spends them all at once.
+    config_pool: bool,
 }
 
 impl Counters {
@@ -74,6 +85,10 @@ impl Counters {
             self.blanket -= 1;
         }
         let mut enabled = blanket;
+        if self.config_pool {
+            self.config_pool = false;
+            enabled = true;
+        }
         for (name, count) in &mut self.named {
             // A name the blanket covers has already come down with it.
             if blanket && reached_by_all(name) {

data/src/rules/lint/unused_method_argument.rs

@@ -230,12 +230,21 @@ fn correction(context: &RuleContext<'_>, variable: &Variable<'_>) -> Option<Edit
                 safe: true,
             })
         }
-        _ => Some(Edit {
-            start: variable.name_node.start_byte(),
-            end: variable.name_node.start_byte(),
-            replacement: "_".to_owned(),
-            safe: true,
-        }),
+        // `corrector.replace(node.loc.name, "_#{variable_name}")`. Writing the whole name rather
+        // than inserting a `_` in front of it matters when another cop is rewriting the same
+        // argument in the same pass: a replacement of the same range clobbers and is deferred to
+        // the next pass, while an insertion at its edge slips out of the range and lands on the
+        // neighbour. The name node already excludes the leading `*` of a splat, which is what the
+        // `gsub(/\A\*+/, '')` there is for.
+        _ => {
+            let name = context.source.node_text(variable.name_node);
+            Some(Edit {
+                start: variable.name_node.start_byte(),
+                end: variable.name_node.end_byte(),
+                replacement: format!("_{name}"),
+                safe: true,
+            })
+        }
     }
 }
 

data/src/rules/mod.rs

@@ -142,6 +142,14 @@ pub(crate) struct RuleContext<'a> {
     fragments: OnceCell<Fragments>,
     /// Which identifiers the Metrics cops read as local variables, replayed once per file.
     metric_locals: OnceCell<Locals>,
+    /// Whether the run has any cop the configuration switches off, which is what an
+    /// `# rubocop:enable all` undoes.
+    ///
+    /// `Registry#disabled_names` is the list upstream walks, and only whether it is empty decides
+    /// the answer. It depends on the run's selection as well as the configuration -- `--only Foo`
+    /// leaves a registry of one cop, and that cop is enabled -- so the engine settles it once
+    /// instead of every cop working it out.
+    run_disables_a_cop: bool,
 }
 
 /// What `Lint/RedundantCopDisableDirective` is given instead of a walk over the syntax tree.
@@ -178,9 +186,16 @@ impl<'a> RuleContext<'a> {
             variables: OnceCell::new(),
             fragments: OnceCell::new(),
             metric_locals: OnceCell::new(),
+            run_disables_a_cop: false,
         }
     }
 
+    /// Records whether the run switches any cop off. See [`Self::run_disables_a_cop`].
+    pub(crate) fn with_disabled_cops(mut self, any: bool) -> Self {
+        self.run_disables_a_cop = any;
+        self
+    }
+
     /// Points the context at the next cop of the same file, keeping everything the file's cops
     /// share -- above all [`Self::variable_analysis`], which would otherwise be run once per cop
     /// that asks for it.
@@ -252,6 +267,12 @@ impl<'a> RuleContext<'a> {
         self.config.rule_enabled(cop)
     }
 
+    /// Whether the run switches any cop off, which is what an `# rubocop:enable all` undoes even
+    /// when the file disabled nothing itself.
+    pub fn run_disables_a_cop(&self) -> bool {
+        self.run_disables_a_cop
+    }
+
     /// The Ruby version the run analyzes as, which version-gated cops compare against.
     pub fn target_ruby_version(&self) -> RubyVersion {
         self.config.target_ruby_version()

data/src/rules/naming/binary_operator_parameter_name.rs

@@ -38,28 +38,31 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         if text == "other" || text == "_other" {
             continue;
         }
-        let variables = variables
-            .get_or_insert_with(|| context.variable_roles());
+        let variables = variables.get_or_insert_with(|| context.variable_roles());
         offenses.push(
             context
                 .offense(
                     format!("When defining the `{name}` operator, name its argument `other`."),
                     parameter.byte_range(),
                 )
-                .corrected_by(rename(context, variables, node, parameter)),
+                .corrected_by_all(rename(context, variables, node, parameter)),
         );
     }
 }
 
-/// One edit standing for the several replacements upstream makes: the parameter and every later
-/// read or assignment of it become `other`, so the edit spans from the parameter to the last of
-/// them and hands back the text in between unchanged.
+/// The replacements upstream makes, one edit each: the parameter and every later read or
+/// assignment of it become `other`.
+///
+/// One edit spanning from the parameter to the last of them would hand back the text in between
+/// unchanged, which reproduces the same output only while nothing else corrects inside it. That
+/// span is the whole method body, so any other cop rewriting a line of it clobbers against this
+/// one and is put off to the next pass.
 fn rename(
     context: &RuleContext<'_>,
     variables: &Variables,
     definition: Node<'_>,
     parameter: Node<'_>,
-) -> Edit {
+) -> Vec<Edit> {
     let name = context.source.node_text(parameter);
     let mut sites = vec![parameter.byte_range()];
     for node in context.nodes_of("identifier") {
@@ -72,22 +75,16 @@ fn rename(
         }
         sites.push(node.byte_range());
     }
-    let start = parameter.start_byte();
-    let end = sites.last().map_or(parameter.end_byte(), |last| last.end);
-    let mut replacement = String::new();
-    let mut cursor = start;
-    for site in &sites {
-        replacement.push_str(context.source.slice(cursor..site.start));
-        replacement.push_str("other");
-        cursor = site.end;
-    }
-    replacement.push_str(context.source.slice(cursor..end));
-    Edit {
-        start,
-        end,
-        replacement,
-        safe: context.setting("Safe").unwrap_or(true),
-    }
+    let safe = context.setting("Safe").unwrap_or(true);
+    sites
+        .into_iter()
+        .map(|site| Edit {
+            start: site.start,
+            end: site.end,
+            replacement: "other".to_owned(),
+            safe,
+        })
+        .collect()
 }
 
 fn operator_method(name: &str) -> bool {

data/src/rules/naming/rescued_exceptions_variable_name.rs

@@ -31,8 +31,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         if name == preferred {
             continue;
         }
-        let variables = variables
-            .get_or_insert_with(|| context.variable_roles());
+        let variables = variables.get_or_insert_with(|| context.variable_roles());
         // `shadowed_variable_name?` asks whether the *configured* name is already read inside the
         // handler. Upstream passes a node where a name is expected, so the underscore prefix never
         // reaches this test.
@@ -46,7 +45,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
                     format!("Use `{preferred}` instead of `{name}`."),
                     range.clone(),
                 )
-                .corrected_by(rename(context, variables, node, range, &name, &preferred)),
+                .corrected_by_all(rename(context, variables, node, range, &name, &preferred)),
         );
     }
 }
@@ -66,9 +65,7 @@ fn exception_variable<'tree>(
         }
         // `rescue => Foo::Bar` is a `casgn` whose name is only the last part, though the offense
         // still covers the whole path.
-        "scope_resolution" => context
-            .source
-            .node_text(target.field("name")?),
+        "scope_resolution" => context.source.node_text(target.field("name")?),
         _ => return None,
     };
     Some((target, name.to_owned()))
@@ -90,7 +87,7 @@ fn reads_name(
     found
 }
 
-/// One edit standing for the several replacements upstream makes: the variable itself, its reads
+/// The replacements upstream makes, one edit each: the variable itself, its reads
 /// inside the handler, and -- when the handler never reassigns it -- its reads in the statements
 /// that follow the `begin`/`end` it belongs to.
 fn rename(
@@ -100,7 +97,7 @@ fn rename(
     variable: Range<usize>,
     name: &str,
     preferred: &str,
-) -> Edit {
+) -> Vec<Edit> {
     let mut rewrite = Rewrite {
         context,
         variables,
@@ -120,25 +117,24 @@ fn rename(
             }
         }
     }
-    let start = variable.start;
-    let end = rewrite
+    // One edit per site, which is what `corrector.replace` is called for upstream. Collapsing them
+    // into a single edit spanning the first site to the last swallows everything written between
+    // them, and that span reaches well past this handler: the reads after the `begin`/`end` are
+    // renamed too, so a second `rescue` further down the file ends up inside it. Its own offence
+    // then clobbers against this one and is put off to the next pass, which leaves a handler whose
+    // body reads the new name while the variable still carries the old one -- and
+    // `Lint/UselessAssignment` deletes the `=> error` it now believes nothing reads.
+    let safe = context.setting("Safe").unwrap_or(true);
+    rewrite
         .sites
-        .last()
-        .map_or(variable.end, |(range, _)| range.end);
-    let mut replacement = String::new();
-    let mut cursor = start;
-    for (range, text) in &rewrite.sites {
-        replacement.push_str(context.source.slice(cursor..range.start));
-        replacement.push_str(text);
-        cursor = range.end;
-    }
-    replacement.push_str(context.source.slice(cursor..end));
-    Edit {
-        start,
-        end,
-        replacement,
-        safe: context.setting("Safe").unwrap_or(true),
-    }
+        .into_iter()
+        .map(|(range, replacement)| Edit {
+            start: range.start,
+            end: range.end,
+            replacement,
+            safe,
+        })
+        .collect()
 }
 
 struct Rewrite<'a, 'tree> {
@@ -182,7 +178,10 @@ impl Rewrite<'_, '_> {
             && self.context.source.node_text(key) == self.name
         {
             let mut cursor = node.walk();
-            if let Some(colon) = node.children(&mut cursor).find(|child| child.kind_str() == ":") {
+            if let Some(colon) = node
+                .children(&mut cursor)
+                .find(|child| child.kind_str() == ":")
+            {
                 let at = colon.end_byte();
                 self.sites.push((at..at, format!(" {}", self.preferred)));
             }

data/src/rules/style/redundant_condition.rs

@@ -502,17 +502,58 @@ fn ternary_form(
     {
         form.push(')');
     }
-    // A conditional written as an argument keeps the `||` from spilling out of the call.
-    let wrapped = node.parent_of(context).is_some_and(|parent| {
-        matches!(parent.kind_str(), "argument_list")
-            || (parent.kind_str() == "call" && parent.field("receiver").is_some())
-    });
+    // `node.parent&.send_type?`: a conditional standing where a send takes an operand keeps the
+    // `||` from spilling out of it.
+    let wrapped = node
+        .parent_of(context)
+        .is_some_and(|parent| stands_in_a_send(context, parent));
     Some(match wrapped {
         true => format!("({form})"),
         false => form,
     })
 }
 
+/// Whether a node holding the conditional is one the parser would have built a `send` for.
+///
+/// The grammar spreads a send over several kinds, and two of those are not sends at all. A logical
+/// operator is an `and`/`or` node upstream rather than a call, and an assignment is a send only
+/// when it writes through `[]=` or an attribute writer -- `x = `, `@x = ` and `X = ` are their own
+/// kinds of assignment, and an operator assignment is an `op-asgn` whatever it writes to. Safe
+/// navigation answers to `csend_type?`, which `send_type?` is false for.
+fn stands_in_a_send(context: &RuleContext<'_>, node: Node<'_>) -> bool {
+    match node.kind_str() {
+        "argument_list" | "element_reference" => true,
+        "call" => node.field("receiver").is_some(),
+        "binary" => !matches!(
+            binary_operator(context, node),
+            Some("&&" | "||" | "and" | "or")
+        ),
+        "assignment" => node
+            .field("left")
+            .is_some_and(|left| match left.kind_str() {
+                "element_reference" => true,
+                "call" => !writes_through_safe_navigation(context, left),
+                _ => false,
+            }),
+        _ => false,
+    }
+}
+
+/// The operator token a binary expression is written with, which the grammar keeps unnamed.
+fn binary_operator<'a>(context: &'a RuleContext<'_>, node: Node<'_>) -> Option<&'a str> {
+    let mut cursor = node.walk();
+    let operator = node
+        .children(&mut cursor)
+        .find(|child| !child.is_named() && !child.is_extra())?;
+    Some(context.source.node_text(operator))
+}
+
+fn writes_through_safe_navigation(context: &RuleContext<'_>, call: Node<'_>) -> bool {
+    let mut cursor = call.walk();
+    call.children(&mut cursor)
+        .any(|child| !child.is_named() && context.source.node_text(child) == "&.")
+}
+
 fn if_source(
     context: &RuleContext<'_>,
     condition: Node<'_>,
@@ -539,10 +580,9 @@ fn if_source(
             if arguments(condition).is_empty() || is_parenthesized(context, condition) {
                 return condition_source.to_owned();
             }
-            let (Some(selector), Some(argument)) = (
-                condition.field("method"),
-                first_argument(condition),
-            ) else {
+            let (Some(selector), Some(argument)) =
+                (condition.field("method"), first_argument(condition))
+            else {
                 return condition_source.to_owned();
             };
             return format!(
@@ -639,9 +679,8 @@ fn requires_parentheses(context: &RuleContext<'_>, node: Node<'_>) -> bool {
 /// `arithmetic_operation?`: one of the operators whose result is a new value.
 fn arithmetic_operation(context: &RuleContext<'_>, node: Node<'_>) -> bool {
     is_send(node)
-        && selector(context, node).is_some_and(|selector| {
-            matches!(selector, "+" | "-" | "*" | "/" | "%" | "**")
-        })
+        && selector(context, node)
+            .is_some_and(|selector| matches!(selector, "+" | "-" | "*" | "/" | "%" | "**"))
         && arguments(node).len() == 1
 }
 

data/src/rules/style/redundant_return.rs

@@ -17,9 +17,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let body = match node.kind_str() {
             "call" => block_body_of_tracked_call(node, context),
             // `-> { ... }` reaches RuboCop as a call to `lambda` too, so its body is a body.
-            "lambda" => node
-                .field("body")
-                .and_then(|block| block.field("body")),
+            "lambda" => node.field("body").and_then(|block| block.field("body")),
             _ => node.field("body"),
         };
         let Some(body) = body else {
@@ -145,6 +143,14 @@ fn check_branch<'tree>(node: Node<'tree>, returns: &mut Vec<Node<'tree>>) {
     }
 }
 
+/// Named children of a statement list that are not statements of it.
+///
+/// A heredoc's body is the one that matters here: the grammar hangs it off the statement list
+/// beside the statement that opened it, so `return <<~SQL` leaves the body standing *after* the
+/// `return`. Counting it makes the `return` no longer the last statement, and the cop then never
+/// fires on a method that ends by returning a heredoc.
+const NOT_A_STATEMENT: &[&str] = &["comment", "empty_statement", "heredoc_body"];
+
 /// The tail of a statement sequence, including the exception-handling clauses it may carry.
 ///
 /// An `ensure` body is never in tail position -- RuboCop's `check_ensure_node` looks only at the
@@ -153,7 +159,7 @@ fn check_sequence<'tree>(node: Node<'tree>, returns: &mut Vec<Node<'tree>>) {
     let mut cursor = node.walk();
     let children: Vec<Node<'tree>> = node
         .named_children(&mut cursor)
-        .filter(|child| child.kind_str() != "comment")
+        .filter(|child| !NOT_A_STATEMENT.contains(&child.kind_str()))
         .collect();
 
     let mut statements: Vec<Node<'tree>> = Vec::new();
@@ -215,7 +221,10 @@ fn return_arguments<'tree>(node: Node<'tree>) -> Vec<Node<'tree>> {
 }
 
 fn braceless_hash(arguments: &[Node<'_>]) -> bool {
-    !arguments.is_empty() && arguments.iter().all(|argument| argument.kind_str() == "pair")
+    !arguments.is_empty()
+        && arguments
+            .iter()
+            .all(|argument| argument.kind_str() == "pair")
 }
 
 /// Mirrors RuboCop's autocorrection: an argument-less `return` becomes `nil`,

metadata

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