sonicop 26.8.104 → 26.8.106

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 267d186a55418ccb97a890bcea5da9eda428dd6567ae4282b61755779783d6e2
-  data.tar.gz: baa0dfdcff20c0a1888222298deab0fd2af37fd9fcd25ef8beb2871bb89083fc
+  metadata.gz: c90ed3a9d03214ba6922d2aecd35c70b28e09791c870f06c22848ef05b336054
+  data.tar.gz: 0557036a886b2023e5151d8b18b1df8bdd66725faf957d19013412a0bc62c6ef
 SHA512:
-  metadata.gz: 1f983d82729522d8a18d1155a4d9b1b6d020b837e987abc2d5bbf14558587997f1abf8808e69ae1e36132b6d15f8cac0d0cf440f116cb9280b98397d7b8f3c03
-  data.tar.gz: 2ffd0dd8db704b600fda62f08c1f61455fc36310f1adc33d4ae6f1bc1b2a53998c8034103a871e4e9e2b239f798a181a66982dafbda3d9b6ae0f5b74845d0887
+  metadata.gz: 63191904f82e06d89200c5b81a22a9ad6a4ebcbf07ed86039966605a2d87225d7984a2dfd7a3b0a7b38ca54aaebc1b36518fdb1eeb5dead16318168e3441d692
+  data.tar.gz: deb43652b8dfd0c2c9fac7ed27a1a33fb1097e76bd2d455851ba04d30d2fc6751025fadfdc4012d06f6a45140a983a5686b7bdfc3e5436e5d9ea0e238da26ddd

data/Cargo.lock

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

data/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sonicop"
-version = "26.8.104"
+version = "26.8.106"
 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.106'
 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/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/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/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/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_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> {