sonicop 26.8.109 → 26.8.110

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af12abdfed80466315a48ac714c41b356e8da379f918ad620ae5a8806751aff3
-  data.tar.gz: 494b54b05f97ce808baaaf0b935f66d76af5ec6b3a19731d90fbda3ab3576d80
+  metadata.gz: a00a7d0dc817fde927c8f9a5eb24db975f85aa2f4dda36ae1f7de548aa6557f6
+  data.tar.gz: 2c09e86e186f680c8f31cf5fd0e979fb974bc23ad173fa14e4f100f98dc95ce3
 SHA512:
-  metadata.gz: c7ea549c725c29d7a1d4574e95dc8ffcf162723babc0782ea07911185640a054724deea5e2777912834bf495ab4b17082641ecadef310364ddb450dd2b2b226d
-  data.tar.gz: 2d1666311efcf108a3c43f1ead16e7c3ceb54e34c40cfed2cc6505d95ed8d7ca25ffba6a2d2d5c20e195c6f481461da27e9ea9134963221340e5ec136e817bd2
+  metadata.gz: 786c6eb994b2d5020f9f035623ec0f54ab95ad3f0359f747efd0bf97fd1bd4cca00d21b7a652b483861aef2af80dabb18dea4185bf9320a214307c4ea8780a8a
+  data.tar.gz: 8c0b93e14e6e7a56f497cc55aad95ce730c681515f9e2f8d67efcfe3c8ae44d98dc8f5ab1bf9c25b60f6de0791b0ed077bc3df0b4a679d3c07416a731426c66d

data/Cargo.lock

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

data/Cargo.toml

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

data/src/config/loader.rs

@@ -11,7 +11,17 @@ pub(super) fn find_config(start: &Path) -> Option<PathBuf> {
         if candidate.is_file() {
             return fs::canonicalize(candidate).ok();
         }
-        if project_root.as_deref().is_none_or(|root| directory == root) {
+        // `break if dir == stop_dir || dir == FileFinder.root_level`
+        //
+        // **`stop_dir` が無いことは「止まらない」であって「止まる」ではない。**
+        // 上流の `find_project_dotfile` は `find_file_upwards(DOTFILE, target_dir, project_root)`
+        // で、`project_root` が nil のときは何とも一致しないので**ファイルシステムの根まで
+        // 昇る**。ここを `is_none_or` で書いていたため、Gemfile の無い木では最初の 1 段で
+        // 止まり、**`.rubocop.yml` がリポジトリ直下・コードが `lib/` という標準の配置で
+        // 設定が 1 つも効かなかった。**
+        //
+        // `ancestors()` は根で終わるので、`root_level` の側は自然に満たされる。
+        if project_root.as_deref() == Some(directory) {
             break;
         }
     }

data/src/engine.rs

@@ -1255,6 +1255,64 @@ fn anchor_range(offense: &Offense, source: &str) -> (usize, usize) {
     }
 }
 
+/// Writes the corrector of every cop of one pass, and what the merge did with it, to stderr under
+/// `SONICOP_TRACE_CORRECTORS`.
+///
+/// The output is the same shape upstream's correctors can be dumped in -- one line per scheduled
+/// edit, `line:column-line:column` then the replacement -- so that the two can be read side by side.
+/// Comparing text alone cannot say *why* a pass landed where it did: a cop whose corrections are
+/// discarded whole still reports every offense as corrected, so the report is identical either way.
+mod trace {
+    pub(super) fn enabled() -> bool {
+        static ENABLED: std::sync::LazyLock<bool> =
+            std::sync::LazyLock::new(|| std::env::var_os("SONICOP_TRACE_CORRECTORS").is_some());
+        *ENABLED
+    }
+
+    /// The 1-based line and column of an offset, counted the way an offense is reported.
+    ///
+    /// Slices with `get` rather than `[..]`: the offsets this walks are the ones under suspicion
+    /// whenever the trace is worth reading, and an offset landing inside a multi-byte character
+    /// would panic exactly when it is being investigated. A malformed edit should print oddly, not
+    /// take the run down.
+    fn position(source: &str, offset: usize) -> (usize, usize) {
+        let mut offset = offset.min(source.len());
+        while offset > 0 && !source.is_char_boundary(offset) {
+            offset -= 1;
+        }
+        let head = &source[..offset];
+        let line = head.bytes().filter(|byte| *byte == b'\n').count() + 1;
+        let start = head.rfind('\n').map_or(0, |index| index + 1);
+        (line, head[start..].chars().count())
+    }
+
+    pub(super) fn span(source: &str, start: usize, end: usize) -> String {
+        let (first_line, first_column) = position(source, start);
+        let (last_line, last_column) = position(source, end);
+        format!("{first_line}:{first_column}-{last_line}:{last_column}")
+    }
+
+    /// Names a cop whose own edits cannot stand together, under `SONICOP_TRACE_OVERLAP`.
+    ///
+    /// The cop-side guard only covers the four cops that reparse their own correction; this end sees
+    /// every cop, because every offense's edits pass through the correction tree. See
+    /// [`crate::rules::support::report_overlap`] for what the stages mean.
+    pub(super) fn overlap(report: &super::FileReport, index: usize, stage: &str) {
+        if !crate::rules::support::overlap_trace_enabled() {
+            return;
+        }
+        let offense = &report.offenses[index];
+        let (line, column) = report.source.line_column(offense.start);
+        crate::rules::support::report_overlap(
+            offense.cop_name,
+            &report.path.display().to_string(),
+            line,
+            column,
+            stage,
+        );
+    }
+}
+
 /// Which cops a correction pass takes edits from.
 ///
 /// RuboCop runs the cop that reads directives on a team of its own, after the inspection loop has
@@ -1320,6 +1378,9 @@ pub fn corrected_text(
     // `Team#each_corrector`'s skip set. See [`autocorrect_incompatible_with`].
     let mut skips: HashSet<&'static str> = HashSet::new();
     let mut rest = candidates.as_slice();
+    if trace::enabled() {
+        eprintln!("=== cop ごとの corrector (マージ順)");
+    }
     while let Some(&first) = rest.first() {
         let cop_name = report.offenses[first].cop_name;
         let taken = rest
@@ -1330,12 +1391,24 @@ pub fn corrected_text(
         rest = remainder;
 
         let skipped = skips.contains(cop_name);
+        if trace::enabled() {
+            eprintln!("  {cop_name}{}", if skipped { "  (skip 済み)" } else { "" });
+        }
 
         // The cop's own corrector. An offense that cannot be placed in it is the cop error RuboCop
         // reports and steps over, so it costs that offense alone.
         let mut cop = Action::root();
         let mut placed = Vec::new();
         for &index in group {
+            if trace::enabled() {
+                for edit in &report.offenses[index].corrections {
+                    eprintln!(
+                        "      {:16} {:?}",
+                        trace::span(source, edit.start, edit.end),
+                        edit.replacement
+                    );
+                }
+            }
             // `combine` rather than `combine_children`: it is the entry point that drops an edit
             // asking for nothing at all, the way `Corrector#replace` and friends do.
             let anchor = anchor_range(&report.offenses[index], source);
@@ -1345,11 +1418,23 @@ pub fn corrected_text(
                 .try_fold(Action::root(), |tree, edit| {
                     tree.combine(&Action::from_edit(edit, anchor))
                 });
-            let Ok(offense) = offense else { continue };
+            let Ok(offense) = offense else {
+                if trace::enabled() {
+                    eprintln!("      ★ この offense の中で衝突");
+                }
+                // The guard that names a corrector written twice over. Reaching it from here covers
+                // every cop; the cop-side path only sees the four that reparse their own correction.
+                trace::overlap(report, index, "offense-tree");
+                continue;
+            };
             if offense.children.is_empty() {
                 continue;
             }
             let Ok(merged) = cop.clone().combine_children(&offense.children) else {
+                if trace::enabled() {
+                    eprintln!("      ★ cop の corrector に入らなかった (この offense だけ捨てた)");
+                }
+                trace::overlap(report, index, "cop-tree");
                 continue;
             };
             cop = merged;
@@ -1378,8 +1463,16 @@ pub fn corrected_text(
                 run = merged;
                 applied += placed.len();
                 trace_outcome("apply", cop_name);
+                if trace::enabled() {
+                    eprintln!("    取り込み");
+                }
+            }
+            Err(_) => {
+                trace_outcome("clash", cop_name);
+                if trace::enabled() {
+                    eprintln!("    ★ 丸ごと捨てた");
+                }
             }
-            Err(_) => trace_outcome("clash", cop_name),
         }
     }
 
@@ -2073,6 +2166,69 @@ mod tests {
         );
     }
 
+    /// The range a cop hands `insert_after` -- not the offset the text lands at -- decides whether
+    /// another cop's replacement of the same construct swallows the insertion or wraps around it.
+    ///
+    /// `Layout/EmptyLineAfterGuardClause` is the pair that measures it: it reports the `end` keyword
+    /// but inserts after `range_by_whole_lines(node.source_range)`, and `Style/IfUnlessModifier`
+    /// replaces exactly that conditional. On the whole lines the insertion is the *parent* of the
+    /// replacement and both land; on the keyword it is a *child* of it, which is the
+    /// `swallowed_insertions` clobbering -- and that costs `Style/IfUnlessModifier` every correction
+    /// it asked for in the file, so a different cop's form wins the node in a later pass. Measured on
+    /// rails' `activerecord/.../schema_definitions.rb`.
+    #[test]
+    fn the_range_an_insertion_hangs_off_decides_who_survives() {
+        let source = "if a\n  raise\nend\nb\n";
+        // `end` is 13..16; the whole lines of the conditional are 0..16; the blank line lands at 16.
+        let insertion = |anchor: std::ops::Range<usize>| {
+            Offense::new(
+                "Layout/EmptyLineAfterGuardClause",
+                Severity::Convention,
+                "test",
+                13,
+                16,
+            )
+            .corrected_by(Edit {
+                start: 16,
+                end: 16,
+                replacement: "\n".to_owned(),
+                safe: true,
+            })
+            .corrections_anchored_at(anchor)
+        };
+        let fold = || {
+            Offense::new(
+                "Style/IfUnlessModifier",
+                Severity::Convention,
+                "test",
+                0,
+                16,
+            )
+            .corrected_by(Edit {
+                start: 0,
+                end: 16,
+                replacement: "raise if a".to_owned(),
+                safe: true,
+            })
+        };
+        let run = |offenses: Vec<Offense>| {
+            let mut report = FileReport {
+                path: "test.rb".into(),
+                source: SourceFile::new("test.rb", source.to_owned()),
+                offenses,
+            };
+            corrected_text(&mut report, CorrectMode::All, Correcting::Everything).0
+        };
+
+        assert_eq!(run(vec![insertion(0..16), fold()]), "raise if a\n\nb\n");
+        // The negative control: anchored on the keyword the fold is swallowed and dropped whole, so
+        // the conditional keeps its written form and only the blank line lands.
+        assert_eq!(
+            run(vec![insertion(13..16), fold()]),
+            "if a\n  raise\nend\n\nb\n"
+        );
+    }
+
     #[test]
     fn a_clobbering_cop_loses_every_correction_it_asked_for() {
         // The cop's second edit collides with what is already scheduled, so the run drops the cop

data/src/rules/layout/empty_line_after_guard_clause.rs

@@ -74,10 +74,13 @@ fn inspect<'tree>(
             return;
         }
         let terminator = terminator_range(context, body);
+        // `range_by_whole_lines(node.loc.heredoc_body)`: the body's own lines, not the statement's.
+        let (edit, anchor) = insertion(context, body.byte_range());
         offenses.push(
             context
                 .offense(MESSAGE, terminator.clone())
-                .corrected_by(insertion(context, body.end_byte())),
+                .corrected_by(edit)
+                .corrections_anchored_at(anchor),
         );
         return;
     }
@@ -86,27 +89,44 @@ fn inspect<'tree>(
         return;
     }
     let range = end_keyword(node).map_or_else(|| node.byte_range(), |keyword| keyword.byte_range());
+    let (edit, anchor) = insertion(context, node.byte_range());
     offenses.push(
         context
             .offense(MESSAGE, range)
-            .corrected_by(insertion(context, node.end_byte())),
+            .corrected_by(edit)
+            .corrections_anchored_at(anchor),
     );
 }
 
 /// `corrector.insert_after(range_by_whole_lines(...), "\n")`, stepping over a directive comment on
 /// the line that follows.
-fn insertion(context: &RuleContext<'_>, end: usize) -> Edit {
-    let line = context.source.line_column(end).0;
-    let mut offset = line_end(context, line);
-    if let Some(comment) = allowed_directive_comment(context, line + 1) {
-        offset = comment.end;
-    }
-    Edit {
-        start: offset,
-        end: offset,
-        replacement: "\n".to_owned(),
-        safe: true,
+///
+/// The second half of the pair is the range upstream hands `insert_after`, which is **not** the
+/// `end` keyword the offense is reported on: it is the whole lines of the conditional. Which of the
+/// two is recorded decides where the insertion sits in the correction tree, and the two fall on
+/// opposite sides of `Style/IfUnlessModifier`'s replacement of the same conditional -- the
+/// whole-lines range contains it, so the two merge, while the `end` keyword is contained by it and
+/// reads as an insertion the replacement swallows. That swallowing is the one RuboCop raises on, and
+/// it costs the clobbering cop every correction it asked for in the file. Measured on
+/// `rails/activerecord/.../schema_definitions.rb`, where recording the keyword sent
+/// `Style/IfUnlessModifier` away and left `Style/GuardClause`'s form in its place.
+fn insertion(context: &RuleContext<'_>, range: Range<usize>) -> (Edit, Range<usize>) {
+    let first_line = context.source.line_column(range.start).0;
+    let last_line = context.source.line_column(range.end).0;
+    let mut anchor = context.source.line_range(first_line).start..line_end(context, last_line);
+    if let Some(comment) = allowed_directive_comment(context, last_line + 1) {
+        anchor = comment;
     }
+    let offset = anchor.end;
+    (
+        Edit {
+            start: offset,
+            end: offset,
+            replacement: "\n".to_owned(),
+            safe: true,
+        },
+        anchor,
+    )
 }
 
 fn line_end(context: &RuleContext<'_>, line: usize) -> usize {

data/src/rules/layout/trailing_whitespace.rs

@@ -9,18 +9,29 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let heredocs = heredocs(context);
     let text = context.source.text();
 
+    // `/[[:blank:]]\z/` and `sub(/[[:blank:]]+\z/, '')`: **the widest of Ruby's three whitespace
+    // sets, and the only one that reaches past ASCII.** A line ending in a no-break space or an
+    // ideographic space carries trailing whitespace upstream, and reading the run as `[' ', '\t']`
+    // left those lines unreported. (A line that *begins* with one parses as an identifier, so the
+    // judgement has to be made on the line's text rather than on a node.)
+    //
+    // **On a source that declares itself binary the set collapses back to ASCII.** `[[:blank:]]`
+    // names Unicode's `Zs`, and an `ASCII-8BIT` string holds no Unicode characters for it to
+    // name -- Ruby matches only tab and space there. The decoder maps each byte of such a file to
+    // one `char` so that columns count bytes, which hands this cop U+00A0 for byte `0xA0`: the
+    // tail of `à`, `Р` or `ภ` written in a comment. Reading that as a no-break space reported 35
+    // lines of `ruby/ruby`'s `test/ruby/test_transcode.rb` that upstream leaves alone, and the
+    // correction **deleted the byte**, leaving a lone `0xC3` where a character had been. The file
+    // still parsed, so nothing downstream noticed.
+    let blank: fn(char) -> bool = match crate::engine::declared_literal_encoding(text) {
+        crate::engine::LiteralEncoding::Binary => |character| matches!(character, ' ' | '\t'),
+        _ => crate::rules::support::is_ruby_blank,
+    };
     for line_number in 1..=context.source.line_count() {
         let range = context.source.line_range(line_number);
         let line = &text[range.clone()];
         let content_end = line.trim_end_matches(['\r', '\n']).len();
-        // `/[[:blank:]]\z/` and `sub(/[[:blank:]]+\z/, '')`: **the widest of Ruby's three whitespace
-        // sets, and the only one that reaches past ASCII.** A line ending in a no-break space or an
-        // ideographic space carries trailing whitespace upstream, and reading the run as `[' ', '\t']`
-        // left those lines unreported. (A line that *begins* with one parses as an identifier, so the
-        // judgement has to be made on the line's text rather than on a node.)
-        let trimmed_end = line[..content_end]
-            .trim_end_matches(crate::rules::support::is_ruby_blank)
-            .len();
+        let trimmed_end = line[..content_end].trim_end_matches(blank).len();
         if trimmed_end == content_end {
             continue;
         }

data/src/rules/lint/literal_as_condition.rs

@@ -4,6 +4,7 @@ use tree_sitter::Node;
 
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
+use crate::rules::send_node;
 use crate::rules::send_node::named_children;
 
 use super::literals::{is_basic_literal, is_falsey_literal, is_literal, is_truthy_literal};
@@ -85,6 +86,10 @@ fn literal(node: Node<'_>, context: &RuleContext<'_>) -> bool {
 const HANDLED: &[&str] = &[
     "binary",
     "unary",
+    // `x.!` is the same `(send _ :!)` upstream reaches through `on_send`, but the grammar writes
+    // it as a `call`. Without it here the negation entry is never reached for that spelling, and
+    // `if 1.!` / `while 1.!` / `until 1.!` / `1.! ? a : b` / `s if 1.!` all go unreported.
+    "call",
     "if",
     "elsif",
     "unless",
@@ -109,7 +114,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     for node in context.nodes_of_any(HANDLED) {
         match node.kind_str() {
             "binary" => check_operator_keyword(node, context, offenses),
-            "unary" => check_negation(node, context, offenses),
+            "unary" | "call" => check_negation(node, context, offenses),
             "while" | "while_modifier" => check_loop(node, true, context, offenses),
             "until" | "until_modifier" => check_loop(node, false, context, offenses),
             "case" => check_case(node, context, offenses),
@@ -168,35 +173,30 @@ fn check_operator_keyword(node: Node<'_>, context: &RuleContext<'_>, offenses: &
 }
 
 /// `on_send` with `RESTRICT_ON_SEND = [:!]`: what a negation is applied to is a condition too.
+///
+/// **The entry uses `negation_method?`, not `prefix_bang?`.** That is why `if not 1` is reported
+/// here while `check_node` -- the recursive half -- leaves it alone: the two halves of this cop ask
+/// different questions, and answering both with one predicate loses a form either way.
 fn check_negation(node: Node<'_>, context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
-    if node
-        .field("operator")
-        .is_none_or(|operator| !matches!(context.source.node_text(operator), "!" | "not"))
-    {
-        return;
-    }
-    let Some(operand) = node.field("operand") else {
+    let Some(found) = send_node::negation(node, context) else {
         return;
     };
-    if literal(operand, context) {
-        offenses.push(report(operand.byte_range(), context));
+    if literal(found.operand, context) {
+        offenses.push(report(found.operand.byte_range(), context));
         return;
     }
-    check_node(operand, context, offenses);
+    check_node(found.operand, context, offenses);
 }
 
 /// `check_node`: the shapes whose operands are conditions in their own right.
 fn check_node(node: Node<'_>, context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
+    // **`prefix_bang?` here, `negation_method?` at the entry.** `not` is excluded on this side, so
+    // widening both to the same predicate reports an operand upstream never looks at.
+    if let Some(found) = send_node::bang(node, context) {
+        handle_node(found.operand, context, offenses);
+        return;
+    }
     match node.kind_str() {
-        "unary"
-            if node
-                .field("operator")
-                .is_some_and(|operator| context.source.node_text(operator) == "!") =>
-        {
-            if let Some(operand) = node.field("operand") {
-                handle_node(operand, context, offenses);
-            }
-        }
         "binary"
             if node
                 .field("operator")

data/src/rules/support.rs

@@ -217,11 +217,12 @@ pub(crate) fn correction_parses(context: &RuleContext<'_>, edits: &[Edit]) -> bo
 /// and the offense it loses never reaches the output to be noticed.
 ///
 /// Set `SONICOP_TRACE_OVERLAP=1` to list them.
+///
+/// This path only sees the cops that verify their own correction by reparsing it -- four of the 609.
+/// The engine reports the same thing for every cop from the other end, where an offense's edits are
+/// folded into the correction tree ([`report_overlap`]); the `stage` field says which end named it.
 fn trace_overlapping_edits(context: &RuleContext<'_>, edits: &[Edit], at: usize) {
-    /// Read once. Every offense of every cop on this path would otherwise pay for the lookup.
-    static ENABLED: std::sync::LazyLock<bool> =
-        std::sync::LazyLock::new(|| std::env::var_os("SONICOP_TRACE_OVERLAP").is_some());
-    if !*ENABLED {
+    if !overlap_trace_enabled() {
         return;
     }
     let mut ordered: Vec<&Edit> = edits.iter().collect();
@@ -230,12 +231,12 @@ fn trace_overlapping_edits(context: &RuleContext<'_>, edits: &[Edit], at: usize)
     for edit in ordered {
         if edit.start < cursor {
             let (line, column) = context.source.line_column(at);
-            eprintln!(
-                "[overlap]\t{}\t{}:{}:{}",
+            report_overlap(
                 context.rule.name,
-                context.source.path().display(),
+                &context.source.path().display().to_string(),
                 line,
-                column
+                column,
+                "reparse-gate",
             );
             return;
         }
@@ -243,6 +244,29 @@ fn trace_overlapping_edits(context: &RuleContext<'_>, edits: &[Edit], at: usize)
     }
 }
 
+/// Read once. Every offense of every cop on these paths would otherwise pay for the lookup.
+pub(crate) fn overlap_trace_enabled() -> bool {
+    static ENABLED: std::sync::LazyLock<bool> =
+        std::sync::LazyLock::new(|| std::env::var_os("SONICOP_TRACE_OVERLAP").is_some());
+    *ENABLED
+}
+
+/// One line naming a cop whose own edits cannot stand together.
+///
+/// `stage` says which end noticed, because the two do not cover the same thing:
+///
+/// * `reparse-gate` -- [`apply_edits`] refused the set while the cop was checking that its own
+///   correction still parses. Only the four cops behind that gate reach it.
+/// * `offense-tree` -- the engine could not fold one offense's edits into a correction tree. Every
+///   cop reaches this one, and it is strictly the worse condition: the tree accepts overlaps that
+///   `apply_edits` refuses (two insertions at one offset merge), so a failure here is a corrector
+///   written twice over rather than a policy call.
+/// * `cop-tree` -- two offenses of the same cop collide. RuboCop reports that as the cop error it
+///   steps over, so it is not by itself a defect, but a cop appearing here often is worth reading.
+pub(crate) fn report_overlap(cop_name: &str, path: &str, line: usize, column: usize, stage: &str) {
+    eprintln!("[overlap]\t{cop_name}\t{path}:{line}:{column}\t{stage}");
+}
+
 /// The source with every edit applied, or `None` when two of them overlap.
 ///
 /// Sorting by span puts an insertion at a span's start before the span itself and one at its end

metadata

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