sonicop 26.8.101 → 26.8.103

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c2383add6601b741d516e8efb4116d217555568a60b08517aa294e42a47fac4
-  data.tar.gz: 65fcd7157dbd75afe11b9f89d069c5c89a34a907517b1c83b022716477d6e373
+  metadata.gz: 11d1ded7e100a86c067bfd508cf4b7b3b402e2c964fb5bcbabb4f95e800551dc
+  data.tar.gz: 2e06b2ad86065842b5fda6dd9b41b798175a87b70633a205fd73fddaa611e1e2
 SHA512:
-  metadata.gz: 410780fd39347da7d2b707a0573ec6ad26d3ed852929abc37d88d492fd499eaf4286790ad09137fb737b173358c8073804aa8d4afd7e6b631630f5a740d6e0c2
-  data.tar.gz: c0905dee79e639abd4cb472b7d7a18c60c198b34f20cef3f84d6ac6a878ce95a2c6fc7e65c7b9e6f90b6e4c32b7da4f0ca7d325ca0f7f4a49cd94c3260434417
+  metadata.gz: e52e6bd4a26c68bd2ed6bda10bfba3772e6760c1573d81c6212391cd0bf1acdccece6b102eed1d9bbf9c2e652556772f12fa626628bb6266d9eee7d94826c314
+  data.tar.gz: 240b544b1e90d355b92025d226d4cdd4efd358e81e9bc26449d5e9f641505230c510b4389487efc936d8e6fcb8fcf281c7b18180ade2a6c0b66fe18c980912df

data/CONFORMANCE.md

@@ -1,109 +1,195 @@
 # RuboCop conformance
 
-Snapshot date: 2026-08-10  
-Reference: RuboCop 1.89.0  
-Corpus: the complete 1,759-file RuboCop source tree  
-Configuration: RuboCop 1.89.0 built-in defaults (`--force-default-config`)
+Snapshot date: 2026-08-14
+Reference: RuboCop 1.89.0 on Ruby 4.0.6
+Configuration: RuboCop 1.89.0 built-in defaults (`--force-default-config`) on both sides
 
 The bundled `config/default.yml` records the upstream version it was vendored from in its header.
 Re-fetch it with `scripts/sync_default_yml.sh <rubocop-version>`.
 
-The comparison covers every cop Sonicop implemented at the snapshot date, listed verbatim in the
-`cops` variable of the command below. Each JSON offense is normalized by path, cop, line, column,
-length, severity, correctability, and message. Run `sonicop --show-cops` for the current set.
-
-| Result | Count |
-|---|---:|
-| Reference offense locations | 4,052 |
-| Sonicop offense locations | 4,052 |
-| Matching locations | 4,052 |
-| False positives | **0** |
-| False negatives | **0** |
-| Location recall | **100%** |
-| Message/severity/correctability differences at matching locations | **0** |
-
-All offenses from the implemented cops match RuboCop by location, message, severity, and
-correctability. This includes RuboCop's source-line indexing for metric cops, line-length
-correctability and exemptions, directive lexing around heredocs, and target-version syntax errors.
-
-Run the harness against a local RuboCop and corpus. It defaults to `rubocop` on `PATH`
-(`gem install rubocop`) as the reference and `./target/release/sonicop` (`make release`) as the
-candidate, so both only need `--reference` / `--candidate` when they live elsewhere — for example
-`--reference "bundle exec rubocop"` inside a bundled project:
+## What is measured
 
-```bash
-cops="Layout/EmptyLineAfterMagicComment,Layout/EndOfLine,Layout/LineLength,Layout/SpaceAfterComma,Layout/SpaceAroundOperators,Layout/SpaceInsideParens,Layout/TrailingEmptyLines,Layout/TrailingWhitespace,Lint/DuplicateMethods,Lint/Syntax,Lint/UnusedBlockArgument,Lint/UselessAssignment,Metrics/BlockLength,Metrics/ClassLength,Metrics/MethodLength,Metrics/ModuleLength,Metrics/ParameterLists,Naming/AsciiIdentifiers,Naming/ConstantName,Naming/MethodName,Naming/VariableName,Security/Eval,Style/FrozenStringLiteralComment,Style/HashSyntax,Style/NumericLiterals,Style/RedundantReturn,Style/Semicolon,Style/StringLiterals"
-
-scripts/conformance_diff.sh \
-  --force-default-config \
-  --cop "${cops}" \
-  -- /path/to/rubocop
-```
-
-`Lint/Syntax` is also run independently over the corpus. The latest owayo tree-sitter grammar
-accepts the modern syntax in all 1,759 files, while Sonicop resolves Ruby 2.6 from the corpus
-gemspec and applies a post-parse syntax feature gate. Its four fatal offenses, including the legacy
-parser recovery diagnostics, exactly match RuboCop.
-
-## Limits of this measurement
+Five Ruby projects, 18,246 target files between them, are linted by both tools and compared offense
+by offense. An offense is keyed by cop name, path, line and column; at each shared key the last
+line, last column, length, message, severity and correctability are compared as well.
 
-The 100% above is a property of *this corpus*, not a general accuracy claim. RuboCop's own source
-tree is RuboCop-clean and stylistically uniform, so entire classes of input never occur in it and
-the comparison cannot exercise them. A cop that is never triggered contributes nothing to the
-match count, and its absence is indistinguishable from agreement.
+| Corpus | Commit | Target files | Reference offenses |
+|---|---|---:|---:|
+| rubocop/rubocop | `f009b33` | 1,765 | 5,766 |
+| rails/rails | `ce95deb` | 3,550 | 167,535 |
+| ruby/ruby | `a9c656e` | 7,465 | 756,427 |
+| Homebrew/brew | `6cf9b12` | 2,176 | 49,733 |
+| mastodon/mastodon | `3f5c32f` | 3,290 | 15,286 |
 
-Two implemented cops are confirmed to produce **zero offenses on both sides** over this corpus, so
-this run says nothing about them:
+ruby/ruby's reference had to be assembled from chunked runs, and 15 files under `test/ruby/` are
+excluded from it: RuboCop finds offenses in them whose text is not valid UTF-8, and its JSON
+formatter raises `source sequence is illegal/malformed utf-8` rather than emitting a document. The
+comparison for that corpus therefore covers 7,450 of its 7,465 files.
 
-| Cop | Offenses in this corpus | Verified elsewhere |
-|---|---:|---|
-| `Layout/TrailingEmptyLines` | 0 | Diverges on line, column, length, and message for a file ending in a blank line |
-| `Naming/AsciiIdentifiers` | 0 | Rails contains exactly two occurrences; both diverge on message casing |
+The **target file lists match exactly** on all five — not just the counts but the paths. That is
+worth stating separately because file discovery is where a port silently diverges first: RuboCop
+never reads `.gitignore`, applies a shebang test only to extensionless files, descends through
+directory symlinks, and treats a hidden path by its *first* component rather than by any dot in it.
 
-Running the same harness over application code rather than linter source surfaces divergences this
-corpus does not. Treat a clean run on any single corpus as evidence about that corpus.
+Sonicop implements **394 of RuboCop's 609 cops**: every cop RuboCop enables by default, matched name
+for name, with nothing extra on either side. The other 215 are the ones RuboCop ships switched off —
+159 `Enabled: pending` and 56 `Enabled: false` — and are not implemented yet.
 
-Two properties of the harness itself also bound what a run can tell you:
+Because the two enabled sets are identical, neither side is restricted with `--only`; the plain run
+is already like for like. RuboCop's extension plugins are not installed, so this measures the range
+that can be checked without them.
 
-- Only the cops passed to `--cop` are compared. Cops that RuboCop reports and Sonicop has not
-  implemented show up as false negatives, which is expected rather than a defect.
-- RuboCop emits **only** `Lint/Syntax` for a file it considers fatally unparseable and suppresses
-  every other cop for that file, while Sonicop keeps inspecting it. Whenever the two disagree
-  about syntax validity — most easily triggered by a `TargetRubyVersion` the source does not
-  satisfy — the false-positive count is dominated by that single behaviour rather than by cop
-  logic. Check the reference output for `"severity": "fatal"` before reading a large false-positive
-  count as a cop problem.
-
-Closing these gaps properly means migrating RuboCop's own spec suite, which exercises each cop
-against inputs written to break it. Until that lands, this document records what was measured, not
-an upper bound on what could differ.
-
-## Rails configuration and scale
-
-Rails source snapshot: `adf307b03b4241cbc0ed3821faf3b153ca6cd5cd` (Rails 8.2.0.alpha).
-The reference process uses RuboCop 1.89.0 with the five plugins declared by Rails:
-rubocop-minitest 0.40.0, rubocop-packaging 0.6.0, rubocop-performance 1.26.1,
-rubocop-rails 2.36.0, and rubocop-md 2.0.4.
+```bash
+rubocop --force-default-config --cache false -f json
+sonicop --force-default-config --format json
+```
 
-This corpus exercises `AllCops/DisabledByDefault`, external plugin cops, recursive excludes,
-hidden paths, and the inherited `guides/.rubocop.yml` configuration.
+## Results
 
-| Compatibility check | RuboCop | Sonicop | Result |
+| Corpus | Excess | Missing | Field differences |
 |---|---:|---:|---|
-| Ruby target files from repository root | 3,453 | 3,453 | Exact paths and order |
-| Enabled cops for `activerecord/lib/active_record.rb` | 107 | 107 | Exact names and order |
-| Enabled cops for a file under `guides/` | 102 | 102 | Exact names and order |
-| Full-tree false positives | — | 0 | Pass |
-
-RuboCop also discovers 75 Markdown targets through rubocop-md. Markdown extraction is outside
-Sonicop's current parser scope, so those files are removed before comparing `-L` output.
-
-The full 3,453-Ruby-file offense comparison reports 10 reference locations and no Sonicop
-locations: zero false positives and 10 visible false negatives. The missing locations are three
-`Style/RedundantPercentQ`, two `Lint/RedundantCopDisableDirective`, two
-`Layout/IndentationWidth`, two unsupported `Lint/DuplicateMethods` cases, and one
-`Lint/Debugger`. Artifacts: `/tmp/sonicop-conformance-rails-full-2`.
-
-On the 402-file `activerecord/lib` subset, a warmed single run with cache and color disabled took
-4.37 seconds for RuboCop and 0.35 seconds for Sonicop (`/usr/bin/time -p`): approximately
-**12.5x faster** on the validation machine.
+| rubocop/rubocop | 0 | 0 | none |
+| rails/rails | 0 | 0 | none |
+| mastodon/mastodon | 0 | 0 | none |
+| Homebrew/brew | 254 | 999 | none |
+| ruby/ruby | 156 | 616 | 5 |
+
+Three of the five agree offense for offense — RuboCop's own tree, Rails and Mastodon — with no
+excess, no shortfall and no metadata differences anywhere.
+
+Homebrew's remaining difference is entirely `Lint/Syntax`; every other cop matches exactly. Much of
+ruby/ruby's is too, with 116 of the 616 missing and 44 of the 156 excess being `Lint/Syntax` itself,
+and the rest follows from it: a file the two disagree about is inspected by one tool and skipped by
+the other, so every offense in it lands on one side of the ledger. That is why the residue there is
+spread thinly across the Layout department instead of sitting in one cop. Both are explained under
+*Known divergences*.
+
+ruby/ruby also carries five differences at positions both tools reported: two `correctable` flags and
+one `last_column`/`length` pair, all on indentation cops inside files the two parse differently, plus
+one `Lint/Syntax` message naming a different token (`tLCURLY` where RuboCop says `tLAMBEG`).
+
+Autocorrect is compared the same way, byte for byte over the whole tree: run `-A` with both tools
+from a clean checkout and diff the results.
+
+| Corpus | Corrected tree |
+|---|---|
+| rubocop/rubocop | **identical** |
+| mastodon/mastodon | **identical** |
+| Homebrew/brew | 2 files differ |
+| rails/rails | 25 files differ |
+| ruby/ruby | not measurable |
+
+RuboCop's own tree and Mastodon are the hard line: a change that breaks byte equality on either is a
+regression to be fixed, not a new known divergence to be recorded.
+
+The rails/rails residue is one shape, and Homebrew contributes one more of it: the body of a
+`begin`/`rescue`/`end` ends up indented two columns off. It appears only in a full `-A` run — the
+first-pass detection matches exactly, and reducing the case to a single file reproduces nothing —
+because what differs is which correction pass a nested indentation fix lands in. Homebrew's other
+file pairs a `disable`/`enable` around `Lint/EmptyBlock`, a cop RuboCop ships as pending; the
+upstream run leaves both comments alone and Sonicop removes them.
+
+ruby/ruby cannot be measured this way at all: RuboCop's own run does not finish on it (see *Reading a
+measurement*), so there is no complete reference tree to diff against.
+
+Run the comparison on a copy of the corpus. Autocorrect rewrites the tree in place, so a run that
+shares a checkout with anything else — another comparison, a lint measurement — has both tools
+reading different files and reports differences that are not there.
+
+## Reading a measurement
+
+Two traps make a run look better or worse than it is, and both have produced wrong conclusions here.
+
+**Counts cancel out.** Comparing offense totals hides an excess and a shortfall of the same size.
+Compare the *set* of locations, then compare fields at the locations both tools produced.
+
+**RuboCop can stop early and still emit valid JSON.** On ruby/ruby its parser raises
+`invalid byte sequence in UTF-8` on `test/ruby/test_regexp.rb` and the whole run unwinds; the JSON
+formatter still writes a well-formed document from an `ensure` block. The result reports 6,924 of
+7,465 files inspected, and the 541 files after that one in sort order were never looked at — so
+every offense Sonicop found in them counts as "excess". Check `summary.inspected_file_count`
+against `summary.target_file_count` on every run. To get a complete reference for that corpus, split
+the file list into chunks and re-run each chunk past the file that killed it.
+
+**And sometimes it emits nothing at all.** Fifteen files under `test/ruby/` hold offenses whose text
+is not valid UTF-8, and `JSONFormatter#finished` raises `source sequence is illegal/malformed utf-8`
+while serializing — before a single byte reaches stdout. The failure therefore looks like an empty
+file rather than a truncated one, and a chunked reference run has to tell it apart from the case
+above: retrying one file at a time is right when a file killed the parser, and useless when the run
+never had a chance to start. Two other stdout notices break JSON the same way — `--parallel` being
+ignored under `--cache false`, and the plugin suggestions RuboCop prints after a run — so a reference
+reader should skip to the first `{` rather than trust byte zero.
+
+## Known divergences
+
+`tests/conformance/known_divergences.yml` is the machine-checked record: a divergence that is listed
+but no longer reproduces fails the test, and so does one that appears without being listed.
+
+### Error recovery after a syntax error
+
+RuboCop parses with `parser`, an LALR parser that recovers from an error and keeps going, emitting
+further diagnostics from the recovered state. Sonicop parses with tree-sitter, which does not model
+that recovery, so the follow-on diagnostics cannot be reproduced. On Homebrew this accounts for the
+999 missing `Lint/Syntax` offenses: `class definition in method body`, `dynamic constant assignment`,
+`cannot assign to a keyword`, and repeated `unexpected token` inside one multi-line hash.
+
+What the divergence does not change is **which** files are held to be unparseable, and that is what
+decides whether a file is inspected at all: RuboCop runs no cop other than `Lint/Syntax` on a file
+that does not parse, and Sonicop does the same. On Homebrew both tools flag the same 568 files —
+neither has one the other lacks. This is why every cop other than `Lint/Syntax` matches exactly there
+despite the 1,253 offenses of difference.
+
+Within those 568 files the agreement is partial, as recovery cannot be reproduced: 498 report the
+same first diagnostic (position and message), and 223 report an identical list end to end. The 70
+files whose first diagnostic differs follow one shape — an endless method definition (`def to_s =
+to_str`, valid from Ruby 3.0, rejected by the default `TargetRubyVersion: 2.7`) leaves `parser`'s
+method context open, so the enclosing `class` emits `class definition in method body` when it is
+finally reduced. The diagnostic is reported at the `class` keyword, far above the line that actually
+failed, which puts it first in source order.
+
+### Grammar gaps
+
+Where tree-sitter rejects code that Ruby accepts, Sonicop reports a syntax error and — following the
+rule above — reports nothing else for that file. One such gap costs every offense in the file at
+once, which makes them worth hunting: fixing eight lexer rules in the grammar fork took ruby/ruby
+from 24 affected files to 5, and cut the offenses Sonicop was missing there by more than sevenfold.
+What is left moves with how many cops are implemented — one unparseable file costs every offense
+every cop would have reported in it — so the shortfall grows as coverage does.
+
+What remains are constructs whose ambiguity Ruby resolves with information a grammar does not have.
+`$a?0:1` is the clearest: whether `?0` is a character literal or the start of a ternary depends on
+whether the token before it completed an expression, which in turn depends on knowing that `a` is a
+local variable rather than a method call.
+
+### Encoding — the one deliberate difference
+
+RuboCop's autocorrect ends in a plain `File.write`, so a corrected Shift_JIS file is written back as
+UTF-8 while its magic comment still claims Shift_JIS. The result no longer loads: read it back as
+cp932 and you get mojibake, not the source you had.
+
+**Sonicop writes the correction back in the encoding the file declares**, and refuses to write at all
+when the correction holds a character that encoding cannot represent, leaving the file untouched
+rather than substituting something else. Drop-in compatibility reaches a long way, but not as far as
+reproducing data loss on purpose. This is the only place Sonicop knowingly differs, and it only
+shows up on files that declare a non-UTF-8 encoding — 8 of the 18,246 files measured here.
+
+A source declaring `ASCII-8BIT` or `binary` needs no such treatment: Ruby measures it one byte at a
+time, so Sonicop reads it that way too and the bytes go back out unchanged.
+
+## Limits
+
+A clean run is a property of the corpora, not a general claim. `known_divergences.yml` carries the
+current list of what these corpora never exercise; the main ones are non-default configuration
+values, extension plugins, and Windows line endings. Cops that never fire contribute nothing to a
+match count, and their silence is indistinguishable from agreement.
+
+The 215 cops RuboCop ships switched off are a limit of a different kind. Sonicop recognizes them —
+they appear in `--show-cops` and a configuration naming them still loads — but it does not implement
+them, so enabling one through `.rubocop.yml` or `--only` checks nothing at all. Sonicop prints a
+warning to stderr in that case rather than letting an unchecked file look clean, but a project whose
+configuration leans on those cops is outside what this document measures.
+
+Closing that gap properly means porting RuboCop's own spec suite, which exercises each cop against
+inputs written to break it. Until that lands, this document records what was measured.
+
+Timings live in the README's Performance section.

data/Cargo.lock

@@ -243,6 +243,15 @@ version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9e5e8f6c15a24b9a3ee5efec809ccd006d3b30e8b3bb63c39af737c7f87daa1d"
 
+[[package]]
+name = "encoding_rs"
+version = "0.8.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
+dependencies = [
+ "cfg-if",
+]
+
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@@ -733,11 +742,12 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sonicop"
-version = "26.8.101"
+version = "26.8.103"
 dependencies = [
  "anyhow",
  "assert_cmd",
  "clap",
+ "encoding_rs",
  "globset",
  "ignore",
  "rayon",
@@ -749,7 +759,6 @@ dependencies = [
  "tempfile",
  "tree-sitter",
  "tree-sitter-ruby",
- "unicode-width",
  "ureq",
 ]
 
@@ -839,7 +848,7 @@ checksum = "009994f150cc0cd50ff54917d5bc8bffe8cad10ca10d81c34da2ec421ae61782"
 [[package]]
 name = "tree-sitter-ruby"
 version = "26.8.100"
-source = "git+https://github.com/owayo/tree-sitter-ruby.git?rev=88a64c6c37c4c23d8d4d804c4ef9c4eca3c88b96#88a64c6c37c4c23d8d4d804c4ef9c4eca3c88b96"
+source = "git+https://github.com/owayo/tree-sitter-ruby.git?rev=6408d8b7adff44f0b346517b56071460efd323b6#6408d8b7adff44f0b346517b56071460efd323b6"
 dependencies = [
  "cc",
  "tree-sitter-language",
@@ -851,12 +860,6 @@ version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
-[[package]]
-name = "unicode-width"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
-
 [[package]]
 name = "unsafe-libyaml"
 version = "0.2.11"

data/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sonicop"
-version = "26.8.101"
+version = "26.8.103"
 edition = "2024"
 rust-version = "1.85"
 description = "A fast, native RuboCop-compatible Ruby linter and formatter"
@@ -17,6 +17,7 @@ path = "src/main.rs"
 [dependencies]
 anyhow = "1.0.104"
 clap = { version = "4.6.4", features = ["derive", "wrap_help"] }
+encoding_rs = "0.8.35"
 globset = "0.4.19"
 ignore = "0.4.31"
 rayon = "1.12.0"
@@ -27,8 +28,7 @@ serde_yaml_ng = "0.10"
 shell-words = "1.1.1"
 tempfile = "3.27.0"
 tree-sitter = "0.26.11"
-tree-sitter-ruby = { git = "https://github.com/owayo/tree-sitter-ruby.git", rev = "88a64c6c37c4c23d8d4d804c4ef9c4eca3c88b96" }
-unicode-width = "0.2.2"
+tree-sitter-ruby = { git = "https://github.com/owayo/tree-sitter-ruby.git", rev = "6408d8b7adff44f0b346517b56071460efd323b6" }
 ureq = { version = "3.4", default-features = false, features = ["native-tls"] }
 
 [dev-dependencies]
@@ -38,3 +38,10 @@ assert_cmd = "2.2.2"
 lto = "thin"
 codegen-units = 1
 strip = true
+
+# `cargo build --profile profiling` keeps the symbols a sampling profiler needs while
+# generating exactly the code `--release` does.
+[profile.profiling]
+inherits = "release"
+debug = 1
+strip = "none"

data/README.ja.md

@@ -32,7 +32,7 @@ CI へ最小限の変更で導入できます。
 
 ## 主な機能
 
-Layout、Lint、Metrics、Naming、Security、Style の各部門の Cop を実装しています。
+Bundler、Gemspec、Layout、Lint、Metrics、Migration、Naming、Security、Style の各部門の Cop を実装しています。
 実装済みの Cop はリリースごとに増えるため、一覧はバイナリ自身が正本です。
 
 ```bash
@@ -107,12 +107,65 @@ Ruby プラグイン実行、キャッシュ再利用、カスタム Cop、実
 
 ### 適合性
 
-実装済み Cop は、正規化した JSON offense を使って RuboCop 1.89 との一致を検証済みです。
-本家の全 1,759 ファイルを本家既定設定で検査した現在のスナップショットは、参照 4,052 件中
-4,052 件すべての位置が一致（**recall 100%**）し、**誤検出とメタデータ差もともに 0 件**です。コマンド、比較範囲、測定結果は
-[CONFORMANCE.md](CONFORMANCE.md) にまとめています。Rails では Ruby 対象 3,453 ファイルと
-ルート／`guides/` の有効 Cop 一覧が完全一致し、全体の誤検出は 0 件です。Active Record
-402 ファイルの無キャッシュ実行は本家比で約 12.5 倍高速でした。
+実装済み Cop は、RuboCop 自身・Rails・Ruby・Homebrew・Mastodon の 5 プロジェクト
+計 18,246 ファイルに対して、両者とも本家既定設定で検証しています。offense は Cop 名・パス・
+行・桁・終端行・終端桁・長さ・メッセージ・重大度・修正可否のすべてで突き合わせます。
+
+5 つのうち 3 つが**完全一致**です。RuboCop 自身のツリー（5,766 件）、Rails（167,535 件）、
+Mastodon（15,286 件）で、過剰も不足もメタデータ差もありません。対象ファイル一覧は 5 つすべてで
+一致します。残る差分は `Lint/Syntax` に集中しており、本家の LALR パーサが構文エラーから回復して
+出す追加診断を tree-sitter では再現できないことによるものです。autocorrect は RuboCop 自身のツリーと
+Mastodon でバイト単位に一致します。この 2 つは死守ラインとして扱い、バイト一致が崩れた場合は
+既知差分ではなく退行として直します。
+
+コマンド、コーパスごとの数値、この種の計測が誤った結論を導く 2 つの罠は
+[CONFORMANCE.md](CONFORMANCE.md) にまとめています。
+
+### 性能
+
+適合性検証に使う 5 コーパスすべてで測定しました。両者とも同梱の既定設定
+（`--force-default-config`）で走らせているためプロジェクト側の `.rubocop.yml` は読まず、
+どのコーパスでも**対象ファイル一覧は完全に一致**しています。
+
+両者とも既定の全 Cop で走らせています。**同じ 394 Cop** が名前まで一致しているため、
+どちらも絞る必要がなく、素の実行がそのまま対等な比較になります。
+各値は暖機後 2 回の最速値です。
+
+| コーパス | ファイル | RuboCop 並列 | Sonicop 並列 | RuboCop 単一 | Sonicop 単一 |
+|---|---:|---:|---:|---:|---:|
+| rubocop/rubocop | 1,765 | 10.64 秒 | **2.84 秒** | 40.66 秒 | **13.60 秒** |
+| mastodon/mastodon | 3,290 | 10.78 秒 | **3.13 秒** | 33.22 秒 | **13.57 秒** |
+| Homebrew/brew | 2,176 | 11.13 秒 | **4.61 秒** | 37.89 秒 | **10.81 秒** |
+| rails/rails | 3,550 | 23.84 秒 | **10.15 秒** | 84.93 秒 | **33.69 秒** |
+| ruby/ruby | 7,465 | 95.71 秒 | **35.74 秒** | 258.87 秒 | **107.37 秒** |
+
+差は並列で 2.4〜3.8 倍、単一プロセスで 2.4〜3.5 倍と幅があり、1 コーパスでは代表できません。
+単一プロセスの列のほうが安定しています。エンジンそのものを測っており、
+各ツールの並列化が対象ツリーにたまたま噛み合ったかどうかに左右されないためです。
+
+仕事を省いて速いわけではありません。この同じ 394 Cop について、RuboCop 自身のツリーと
+Mastodon では**すべての offense が一致**し、autocorrect もバイト単位で一致します。
+
+再現時に注意が必要な点が 2 つあります。RuboCop は **`--cache false` と併用すると
+`--parallel` を黙って無効化します**。そのためここでの並列実行はキャッシュを有効にしたうえで
+実行ごとにキャッシュディレクトリを消しており、`--cache false --parallel` で計測すると
+単一プロセスを測ることになり差が過大に出ます。また RuboCop の既定は単一プロセス、
+Sonicop は `--no-parallel` を渡さない限り並列です。
+
+```bash
+# RuboCop（並列・キャッシュは毎回空・既定の全 394 Cop）
+rubocop --force-default-config --cache true --cache-root "$(mktemp -d)" \
+        --no-color --parallel -f quiet
+
+# Sonicop
+sonicop --force-default-config --format quiet
+```
+
+測定機は Apple M2（8 コア）、Ruby 4.0.6（YJIT 利用可）、RubyGems 導入の RuboCop 1.89.0。
+上の値は 1 分平均のロードアベレージが 4〜29 の状態で採ったもので、**アイドル状態ではありません**。
+両者を同じ条件で測っているため倍率は保たれますが、秒数そのものは下限ではなく、静かなマシンなら
+より速く出ます。コアを奪い合うものが動いていると両者とも膨らみ、その度合いは一致しないため、
+秒数そのものが重要なときは他に負荷のない状態で測ってください。
 
 ## 開発
 

data/README.md

@@ -32,7 +32,8 @@ existing editor and CI integrations with minimal changes.
 
 ## Features
 
-Sonicop implements cops in the Layout, Lint, Metrics, Naming, Security, and Style departments.
+Sonicop implements cops in the Bundler, Gemspec, Layout, Lint, Metrics, Migration, Naming,
+Security, and Style departments.
 The implemented set grows with each release, so the binary itself is the authoritative list:
 
 ```bash
@@ -116,13 +117,67 @@ reuse, custom Ruby cops, or cops outside the implemented set.
 
 ### Conformance
 
-The implemented cops are verified against RuboCop 1.89 using normalized JSON offenses.
-On RuboCop's complete 1,759-file source tree with the upstream default configuration, the current
-snapshot matches all 4,052 reference offense locations (**100% recall**) with **zero false
-positives and zero metadata differences**. On Rails, all 3,453 Ruby target paths and the root/nested enabled-cop lists match
-exactly, the full tree has zero false positives, and the 402-file Active Record subset runs about
-12.5x faster without cache. See [CONFORMANCE.md](CONFORMANCE.md) for the commands, scope, and
-measurements.
+The implemented cops are verified against RuboCop 1.89.0 over five Ruby projects — RuboCop itself,
+Rails, Ruby, Homebrew and Mastodon — totalling 18,246 files, with the upstream default
+configuration on both sides. Every offense is compared by cop, path, line, column, last line, last
+column, length, message, severity and correctability.
+
+Three of the five match **exactly**: RuboCop's own tree (5,766 offenses), Rails (167,535) and
+Mastodon (15,286), with no excess, no shortfall and no metadata differences. The target file lists
+match exactly on all five. What remains is concentrated in `Lint/Syntax`, where RuboCop's LALR
+parser recovers from an error and emits diagnostics a tree-sitter parse cannot reconstruct.
+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.
+
+### Performance
+
+Measured over all five conformance corpora. Both tools were given their own bundled default
+configuration (`--force-default-config`), so neither reads the project's `.rubocop.yml`, and on every
+corpus the two resolve **the same file list**.
+
+Both tools run their full default set — **the same 394 cops**, matched name for name — so neither
+side is restricted and the comparison is like-for-like as it stands. Times are the fastest of two
+warmed runs.
+
+| Corpus | Files | RuboCop parallel | Sonicop parallel | RuboCop single | Sonicop single |
+|---|---:|---:|---:|---:|---:|
+| rubocop/rubocop | 1,765 | 10.64 s | **2.84 s** | 40.66 s | **13.60 s** |
+| mastodon/mastodon | 3,290 | 10.78 s | **3.13 s** | 33.22 s | **13.57 s** |
+| Homebrew/brew | 2,176 | 11.13 s | **4.61 s** | 37.89 s | **10.81 s** |
+| rails/rails | 3,550 | 23.84 s | **10.15 s** | 84.93 s | **33.69 s** |
+| ruby/ruby | 7,465 | 95.71 s | **35.74 s** | 258.87 s | **107.37 s** |
+
+The gap is 2.4x to 3.8x in parallel and 2.4x to 3.5x single-process, so no single corpus summarizes
+it. The single-process column is the steadier of the two — it measures the engines rather than how
+well each one's parallelism happens to fit the tree it was pointed at.
+
+The speed is not bought by skipping work: over those same 394 cops the two agree on **every offense**
+on RuboCop's own tree and on Mastodon, and autocorrect there is byte-identical.
+
+Two details matter for reproducing this. RuboCop **silently turns `--parallel` off when combined
+with `--cache false`**, so its parallel runs here use a cache directory that is deleted before each
+run rather than disabled; timing it with `--cache false --parallel` measures a single process and
+overstates the difference. RuboCop's default is a single process, while Sonicop is parallel unless
+`--no-parallel` is passed.
+
+```bash
+# RuboCop, parallel, cold cache, its full default set of 394 cops
+rubocop --force-default-config --cache true --cache-root "$(mktemp -d)" \
+        --no-color --parallel -f quiet
+
+# Sonicop
+sonicop --force-default-config --format quiet
+```
+
+Machine: Apple M2 (8 cores), Ruby 4.0.6 with YJIT available, RubyGems-installed RuboCop 1.89.0.
+The numbers above were taken with a one-minute load average between 4 and 29 — the machine was in
+use, not idle. Both tools ran under the same conditions, so the ratios hold, but the absolute
+seconds are not a floor: expect better on a quiet machine. Anything competing for cores inflates
+both sides, and not by the same factor on each, so measure on an otherwise idle machine when the
+absolute numbers matter to you.
 
 ## Development
 

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.101'
+  VERSION = '26.8.103'
 end