rigortype 0.1.17 → 0.1.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9379e94547d874f10fc2fcb79e354b16d0459350bdd68a9025dc5bd0ee6bdc3d
-  data.tar.gz: 4b773c4952be32d673358758340d85a34f9839890eede1669ff863a779b30d69
+  metadata.gz: 6e2fede9ea7407238b1f9c8f5784cc43f22724ee86decdf81f4a148c4ddff763
+  data.tar.gz: 57e9757b838f29185d9b936ddff586d372126540afe12cefb1e98dbc7e0a6109
 SHA512:
-  metadata.gz: '08680ad9e159ff52c031548a45e862539419f0719a251b0b46dc3dddc5313373a7434806024429c1ebf1c580bafcdb7507fed1b2574139c17cb2394129bc0581'
-  data.tar.gz: 4469fa97e287f84772543d0525866a733fd0e075c486e8a8dc650b09e31a1a02e1b91602d61b0678de9c2fb914bd999a4cea998e0ab6c39f3ee4970892e3b39c
+  metadata.gz: 33b889562fefed7516dec175b7d85cc9f725ebcc7d94df30b5a58a436322709517a02bda2a0de10d746004c8c2d198aaa673f12577ddfe3ffeb37405508e1d9c
+  data.tar.gz: f5773b727c0fb718df1ab1163add87f0dd7e94913fefd0599e7465e5a40afbfa201b2b14a09eb524b2e98dc6e30bd84ab0424355802ded977386f5a706d84837

data/README.md

@@ -4,276 +4,213 @@
 [![GitHub License](https://img.shields.io/github/license/rigortype/rigor)](https://github.com/rigortype/rigor/blob/master/LICENSE)
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/rigortype/rigor)
 
-**Inference-first static analysis for Ruby.** Run `rigor check` over your
-code — no annotations, no runtime dependency, no DSL.
+**Type-aware bug finding for Ruby — zero annotations, and a
+zero-false-positive bar enforced against real codebases.** Run one
+command over the code you already have, and trust every line of
+output.
 
-Rigor parses Ruby with [Prism](https://github.com/ruby/prism), runs a
-flow-sensitive type-inference engine over each file, and reports a small
-but trustworthy catalogue of bugs: undefined methods on typed receivers,
-wrong-argument-count calls, provable divisions by zero, and more.
-
-**Your team never needs to write type annotations** — Rigor derives
-everything from the code itself. An AI Skill gets a project running in
-minutes with a configuration tailored to its stack. When you want to go
-deeper — tighter checks, framework-aware analysis, your own refinements —
-Rigor's type system is remarkably powerful, and a Skill takes you there
-step-by-step.
+```sh
+gem install rigortype && rigor check app lib
+```
 
-**Three design commitments drive Rigor.**
+(The tool itself runs on Ruby 4.0; your project can stay on whatever
+Ruby it targets — see [Get started](#get-started-in-one-prompt).)
 
-1. **Types are facts, not wishes.** Hand-written annotations drift the
-   moment they are written. Rigor infers from the code itself — every
-   type is derived from what your source actually produces. When you do
-   want RBS in `sig/`, [`rigor sig-gen`](https://rigor.typedduck.fail/reference/adr/14-rbs-sig-generation/)
-   emits it from inference results so the written form starts in sync
-   with reality.
-2. **Your specs are types.** Do you really need to write type
-   annotations? Your `spec/` is already type information. RSpec
-   `expect(x).to be_a(T)` / `eq(literal)` assertions contribute
-   narrowing facts from that point forward; `subject` / `let` bindings
-   propagate the SUT's type into downstream `it` bodies; factory
-   definitions in `spec/factories/` feed attribute shapes back into
-   `rigor-activerecord` and `rigor-factorybot`'s cross-plugin channels.
-   The test suite you already have becomes a live type oracle.
-3. **Programmable inference beyond unions.** A plain union
-   (`Integer | nil`) is not the type story Ruby needs. Rigor reasons
-   about *what values an expression actually produces* — literal values,
-   integer ranges, refinement carriers, per-position tuple / hash shapes
-   — and exposes a plugin API plus a
-   [macro / DSL expansion substrate](https://rigor.typedduck.fail/reference/adr/16-macro-expansion/)
-   so Rails-shape DSLs become first-class type sources.
+No type annotations to write or maintain, no runtime dependency, no
+changes to your code. Rigor parses Ruby with
+[Prism](https://github.com/ruby/prism) and runs a flow-sensitive
+inference engine that reasons about the *values* your expressions
+produce — not just their classes. It catches undefined methods (and
+typos) on inferred receivers, wrong argument counts, receivers that
+can be `nil` on a live path, unreachable branches and `case` clauses,
+and conditions that can only ever be truthy.
 
-## Installation
+## Hello, Rigor
 
-Rigor is a tool, not a library — install it independently, **not** in
-your project's `Gemfile`. It runs on Ruby 4.0, regardless of which Ruby
-version your project targets.
+A realistic typo, caught with the receiver's *computed value* in the
+message:
 
-**Using an AI coding agent?** Hand it this prompt and it will detect
-your environment, install Rigor, and kick off the project-init Skill
-automatically:
+```ruby
+# demo.rb
+def slug(title)
+  title.downcase.gsub(/\s+/, "-")
+end
 
-```
-Install Rigor in this project by following the instructions at
-https://raw.githubusercontent.com/rigortype/rigor/refs/heads/master/docs/install.md
+s = slug("Hello World")
+s.lenght
 ```
 
-Prefer to set up in your language? Find prompts for Japanese, Chinese,
-Korean, Portuguese, Spanish, French, German, Italian, Vietnamese, Thai,
-Indonesian, Polish, Ukrainian, Russian, Romanian, and Turkish at
-[docs/manual/14-rails-quickstart.md](docs/manual/14-rails-quickstart.md#step-1--install-ruby-40-and-rigor-common-to-both-paths)
-(or the [online version](https://rigor.typedduck.fail/reference/manual/14-rails-quickstart/)).
-
-**Manual install** — the recommended path uses
-[`mise`](https://mise.jdx.dev/), which provisions both Ruby 4.0 and
-Rigor pinned per project:
-
-```sh
-mise use ruby@4.0
-mise use gem:rigortype
+```shell-session
+$ rigor check demo.rb
+demo.rb:7:3: error: undefined method `lenght' for "hello-world"
 ```
 
-If you already have Ruby 4.0 available, `gem install rigortype` works too.
-The gem is named `rigortype` (the name `rigor` was taken on RubyGems);
-the executable it installs is `rigor`.
-
-Full options — `asdf`, dev containers, CI workflow template — are in the
-[installation guide](https://rigor.typedduck.fail/reference/manual/01-installation/)
-and [CI guide](https://rigor.typedduck.fail/reference/manual/11-ci/).
+Note what the error says: not ``undefined method `lenght' for String``
+but **`for "hello-world"`** — Rigor traced the value through the
+method call and the `downcase.gsub` chain, with no annotations
+anywhere.
 
-## Getting started with AI Skills
+To see what Rigor sees, run `rigor annotate fact.rb` — it reprints
+the file with the inferred type of every line in the margin. The
+`#=>` comments below are **added by `annotate`**, not part of the
+source:
 
-The fastest path from zero to a running Rigor setup is the
-**`rigor-project-init` Skill** — an AI agent skill bundled under
-[`skills/`](skills/) that detects your stack, recommends the right plugins,
-and writes `.rigor.dist.yml` for you:
+```ruby
+# fact.rb
+def factorial(n)        #=> Integer
+  (1..n).reduce(1, :*)  #=> Integer
+end                     #=> :factorial
 
-```
-# In Claude Code or any AI assistant that supports Agent Skills:
-Use the rigor-project-init skill
+answer = factorial(5)   #=> 120
 ```
 
-The Skill walks your `Gemfile`, proposes a plugin set matched to your
-framework (Rails, Sinatra, dry-rb, …), lets you choose an adoption mode —
-**baseline** (acknowledge existing diagnostics and work them down
-incrementally) or **strict** (zero-diagnostic gate from day one) — then
-commits a ready-to-use configuration. No manual YAML editing required.
+No signature on `factorial`, yet the method types as `Integer` — and
+at the call site, where the argument is known, Rigor folds the whole
+computation down to the *value* `120`. The same machinery tracks hash
+shapes through your params, string values through builder chains, and
+`nil` through guard clauses in everyday application code. (Output is
+syntax-highlighted — through [`bat`](https://github.com/sharkdp/bat)
+when installed.)
 
-Two companion Skills continue the journey once you are up and running:
+## Get started in one prompt
 
-| Skill | Use when |
-| --- | --- |
-| [`rigor-baseline-reduce`](skills/rigor-baseline-reduce/) | Reducing an existing baseline: `rigor triage` prioritisation → site-by-site classification → fix / `# rigor:disable` / open a Rigor issue |
-| [`rigor-plugin-author`](skills/rigor-plugin-author/) | Teaching Rigor about a project-specific DSL or framework — authors the plugin gem or project-private plugin |
+The fastest path is to hand your AI coding agent (Claude Code, Cursor,
+or any assistant that follows instructions from a URL) this prompt:
 
-All three Skills follow the [agentskills.io](https://agentskills.io/)
-convention and work with any AI assistant that discovers skills in your
-project directory.
-
-## Quick start
-
-```sh
-# Check lib/ for bugs.
-rigor check lib
-
-# Drop a starter .rigor.yml.
-rigor init
+```
+Install Rigor in this project by following the instructions at
+https://raw.githubusercontent.com/rigortype/rigor/refs/heads/master/docs/install.md
+```
 
-# Print the inferred type at a precise FILE:LINE:COL position.
-rigor type-of lib/foo.rb:10:5
+It installs Rigor, then runs the bundled **`rigor-project-init`**
+[Agent Skill](https://agentskills.io/): it walks your `Gemfile`,
+proposes plugins matched to your stack (Rails, Sinatra, dry-rb, …),
+lets you pick an adoption mode — **baseline** (acknowledge existing
+diagnostics, work them down incrementally) or **strict**
+(zero-diagnostic gate from day one) — and commits a ready-to-use
+configuration.
 
-# Summarise the diagnostic stream: distribution, hotspots, heuristic hints.
-rigor triage lib
+**This works in your language.** The prompt is plain natural
+language, so you can write it — and run the whole setup conversation
+— in your mother tongue. In Japanese, for example:
 
-# Emit RBS from inference results — review with --diff, write with --write.
-rigor sig-gen --diff  lib/foo.rb
-rigor sig-gen --write lib/foo.rb
+```
+次の手順に従って、このプロジェクトに Rigor をインストールしてください:
+https://raw.githubusercontent.com/rigortype/rigor/refs/heads/master/docs/install.md
 ```
 
-### Sample output
+Ready-made prompts — 日本語, 简体中文, 繁體中文, 한국어, Español,
+Português, Français, Deutsch, Italiano, Tiếng Việt, ภาษาไทย,
+Bahasa Indonesia, Polski, Українська, Русский, Română, Türkçe,
+العربية, فارسی — are in
+the [installation guide](https://rigor.typedduck.fail/reference/manual/01-installation/#set-up-in-your-language).
 
-```sh
-$ cat /tmp/demo.rb
-"hello".no_such_method        # undefined method
-[1, 2, 3].rotate(1, 2)        # wrong number of arguments
+**Manual install** — Rigor is a tool, not a library: install it
+independently, **not** in your project's `Gemfile`. It runs on Ruby
+4.0 regardless of which Ruby your project targets
+([`mise`](https://mise.jdx.dev/) provisions both, pinned per project):
 
-$ rigor check /tmp/demo.rb
-/tmp/demo.rb:1:9: error: undefined method `no_such_method' for "hello"
-/tmp/demo.rb:2:11: error: wrong number of arguments to `rotate' on Array (given 2, expected 0..1)
+```sh
+mise use ruby@4.0
+mise use gem:rigortype     # or: gem install rigortype
 ```
 
-Diagnostics fire only when the receiver type is statically known and the
-evidence is conclusive — Rigor never surfaces a warning it cannot prove.
-
-### Faster runs through the cache
+The gem is named `rigortype` (the name `rigor` was taken on RubyGems);
+the executable is `rigor`. `asdf`, dev containers, and CI templates are
+in the [installation guide](https://rigor.typedduck.fail/reference/manual/01-installation/)
+and [CI guide](https://rigor.typedduck.fail/reference/manual/11-ci/).
 
-Rigor caches RBS work (loaded environment, type translation, class
-hierarchy) under `.rigor/cache/` — the second `rigor check` is
-significantly faster than the first. Add `.rigor/` to your `.gitignore`.
+### Daily commands
 
 ```sh
-rigor check --cache-stats lib   # inspect cache hit/miss
-rigor check --clear-cache lib   # wipe if you suspect staleness
-```
-
-## The type vocabulary
-
-A vanilla type checker answers "what *class* is this object?" Rigor
-answers "what *subset of values* can this expression produce?" — tracking
-literal values, integer ranges, refinement carriers, and structural shapes
-through the whole analysis, without a single annotation.
-
-| Carrier | What it records | Example |
-| --- | --- | --- |
-| **Literal** (`Constant`) | A single Ruby value | `Constant<42>`, `Constant<"hello">`, `Constant<:foo>` |
-| **Integer range** | A bounded interval | `positive-int = int<1, max>`, `int<5, 10>` |
-| **Refinement** | Base type minus a point, or restricted by a predicate | `non-empty-string = String - ""`, `lowercase-string` |
-| **Tuple / HashShape** | Heterogeneous arrays / known-key hashes | `[1, "two"]` → `Tuple[Constant<1>, Constant<"two">]` |
-| **Union** | Finite enumerable set of literals | `Constant<:zero> \| Constant<:small> \| Constant<:large>` |
-| **`Dynamic[T]`** | Gradual carrier — "could be anything" | `Dynamic[Top]` when proof is unavailable |
-
-Every narrower carrier **erases to its base class** for RBS interop, so
-importing Rigor is a strictly additive change.
-
-The full type model — constant folding, `Method` bindings, LightweightHKT,
-`RBS::Extended` directives — is in the
-[handbook](https://rigor.typedduck.fail/reference/handbook/) and
-[type specification](https://rigor.typedduck.fail/reference/type-specification/).
-
-### Unlocking tighter types with `RBS::Extended`
-
-When you *want* to express more than RBS allows, attach a
-`%a{rigor:v1:…}` annotation in your `sig/` file. The annotation is a
-no-op for ordinary RBS tools; Rigor uses it to tighten call-site and
-body types.
-
-```rbs
-class Slug
-  %a{rigor:v1:return: non-empty-string}
-  %a{rigor:v1:param: id is non-empty-string}
-  def normalise: (::String id) -> ::String
-end
+rigor check lib                 # find bugs (caches under .rigor/ — gitignore it)
+rigor init                      # drop a starter .rigor.yml
+rigor annotate lib/foo.rb       # reprint a file with inferred types in the margin
+rigor triage lib                # summarise diagnostics: distribution, hotspots
+rigor sig-gen --diff lib/foo.rb # emit RBS from inference (--write to save)
 ```
 
-This is entirely optional — Rigor runs without any annotations.
-The directive grammar and the full refinement-name catalogue are in
-[`RBS::Extended`](https://rigor.typedduck.fail/reference/type-specification/rbs-extended/)
-and [imported built-in types](https://rigor.typedduck.fail/reference/type-specification/imported-built-in-types/).
+In CI, `rigor check` auto-detects the platform and emits native output
+(GitHub annotations, GitLab Code Quality, SARIF, Checkstyle, JUnit,
+TeamCity).
 
-## Plugins
+## Three design commitments
 
-Production plugins ship under [`plugins/`](plugins/) for the most common
-Ruby frameworks and gems. Activate them in `.rigor.yml`:
+1. **Types are facts, not wishes.** Hand-written annotations drift the
+   moment they are written. Rigor infers from the code itself — every
+   type is derived from what your source actually produces. When you do
+   want RBS in `sig/`, [`rigor sig-gen`](https://rigor.typedduck.fail/reference/adr/14-rbs-sig-generation/)
+   emits it from inference results so the written form starts in sync
+   with reality.
+2. **A false positive is the worst bug.** Your program works; a
+   static analyzer that argues otherwise is the thing that is wrong.
+   Rigor fires a diagnostic only when the receiver type is statically
+   known and the evidence is conclusive — never on a value it merely
+   failed to prove things about — and every precision change is gated
+   on real OSS codebases (Mastodon, Redmine, GitLab FOSS) before it
+   ships. You should never have to write defensive code, or a
+   suppression comment, to calm the analyzer down.
+3. **Programmable inference beyond unions.** A plain union
+   (`Integer | nil`) is not the type story Ruby needs. Rigor tracks
+   literal values, integer ranges, refinements like
+   `non-empty-string`, and per-position tuple / hash shapes — and
+   exposes a plugin API plus a
+   [macro / DSL expansion substrate](https://rigor.typedduck.fail/reference/adr/16-macro-expansion/)
+   so Rails-shape DSLs become first-class type sources.
 
-```yaml
-plugins:
-  - rigor-activerecord
-  - rigor-actionpack
-  - rigor-rspec
-```
+## Works with your stack
 
-**Rails ecosystem** — [`rigor-rails-routes`](plugins/rigor-rails-routes/),
-[`rigor-rails-i18n`](plugins/rigor-rails-i18n/),
-[`rigor-activerecord`](plugins/rigor-activerecord/),
-[`rigor-actionpack`](plugins/rigor-actionpack/),
-[`rigor-actionmailer`](plugins/rigor-actionmailer/),
-[`rigor-activejob`](plugins/rigor-activejob/),
-[`rigor-factorybot`](plugins/rigor-factorybot/),
-[`rigor-pundit`](plugins/rigor-pundit/),
-[`rigor-sidekiq`](plugins/rigor-sidekiq/).
-
-**Other frameworks** — [`rigor-sinatra`](plugins/rigor-sinatra/),
-[`rigor-devise`](plugins/rigor-devise/),
-[`rigor-dry-struct`](plugins/rigor-dry-struct/),
-[`rigor-rspec`](plugins/rigor-rspec/),
-[`rigor-actioncable`](plugins/rigor-actioncable/).
-
-**Type-system extensions** — [`rigor-sorbet`](plugins/rigor-sorbet/)
-(ingests Sorbet `sig` / `T.let` / RBI files),
-[`rigor-statesman`](plugins/rigor-statesman/),
-[`rigor-typescript-utility-types`](plugins/rigor-typescript-utility-types/).
-
-See [`plugins/README.md`](plugins/README.md) for the full catalogue. To
-write a plugin for your own DSL or framework, use the
-[`rigor-plugin-author`](skills/rigor-plugin-author/) Skill described above.
-Plugin-contract walkthroughs (simplified virtual use cases spotlighting
-one extension surface each) are under [`examples/`](examples/).
-
-## Configuration
-
-`rigor init` writes a starter `.rigor.yml`. Most projects only need a
-handful of lines:
+Production plugins ship in-repo for the common frameworks and gems —
+**Rails** (ActiveRecord, ActionPack, routes, i18n, jobs, mailers),
+**testing** (RSpec, FactoryBot, minitest), **ecosystem** (Sidekiq,
+Devise, Pundit, Sinatra, dry-rb, GraphQL), and **type-system bridges**
+(`rigor-sorbet` ingests Sorbet `sig` / RBI files, so Rigor runs
+alongside an existing Sorbet setup). If you already maintain RBS in
+`sig/` — from Steep or by hand — Rigor reads it as a type source
+out of the box. Activate plugins in `.rigor.yml`:
 
 ```yaml
 paths: [lib, app]
-target_ruby: "3.3"
 plugins:
   - rigor-activerecord
   - rigor-actionpack
-baseline: .rigor-baseline.yml   # when using baseline adoption mode
+  - rigor-rspec
 ```
 
-Common knobs: `disable` (rule IDs to silence project-wide),
-`signature_paths` (additional `sig/`-style directories),
-`dependencies.source_inference` (opt-in gem-source walk for gems
-without RBS). The `rigor-project-init` Skill writes and populates all
-of this for you. Full reference on the
-[website](https://rigor.typedduck.fail/).
-
-In-source suppression: `# rigor:disable <rule>` silences a single line;
-`# rigor:disable all` suppresses every rule on that line.
+The full catalogue is in [`plugins/README.md`](plugins/README.md); the
+`rigor-project-init` Skill picks the right set for you. To teach Rigor
+your own DSL, the [`rigor-plugin-author`](skills/rigor-plugin-author/)
+Skill authors a plugin step-by-step, and
+[`rigor-baseline-reduce`](skills/rigor-baseline-reduce/) drives the
+baseline down once you are running.
+
+## Going deeper
+
+Where a vanilla checker answers "what *class* is this?", Rigor answers
+"what *subset of values* can this expression produce?" — literal
+values (`Constant<"hello">`), integer ranges (`positive-int`),
+refinements (`non-empty-string = String - ""`), tuple and known-key
+hash shapes. Every narrower carrier erases to its base class for RBS
+interop, so adopting Rigor is strictly additive. When you want to
+*declare* more than RBS can say, optional `%a{rigor:v1:…}` annotations
+in `sig/` files tighten types while staying a no-op for ordinary RBS
+tools.
+
+The twelve-chapter [handbook](https://rigor.typedduck.fail/reference/handbook/)
+walks the whole type model; the
+[type specification](https://rigor.typedduck.fail/reference/type-specification/)
+and [user manual](https://rigor.typedduck.fail/reference/manual/) are
+the reference companions.
 
 ## Status
 
-Current released version: **`v0.1.15`** (2026-05-29). The analyzer is
-usable on real Ruby code today; the rule catalogue is deliberately
-conservative — Rigor's stance is to surface zero false positives while
-the inference surface stabilises. The `0.1.x` preview line has been
-hardened against real OSS Rails codebases (Mastodon / Redmine / GitLab
-FOSS); `v0.2.0` will open the first evaluation release.
-
-Release history: [`CHANGELOG.md`](CHANGELOG.md). Forward-looking
-commitments: [Roadmap](https://rigor.typedduck.fail/reference/roadmap/).
+Current release: **`v0.1.18`** (2026-06-11), with `v0.2.0` — the first
+evaluation release — landing shortly. Rigor analyses real Ruby today:
+the `0.1.x` line has been hardened against Mastodon, Redmine, and
+GitLab FOSS, and the deliberately conservative rule catalogue grows
+only as fast as the zero-false-positive bar allows. Release history:
+[`CHANGELOG.md`](CHANGELOG.md) · forward-looking commitments:
+[Roadmap](https://rigor.typedduck.fail/reference/roadmap/).
 
 ## Contributing
 

data/lib/rigor/analysis/check_rules/always_truthy_condition_collector.rb

@@ -56,6 +56,14 @@ module Rigor
 
         Result = Data.define(:node, :polarity)
 
+        # ADR-53 Track B — the node classes the shared {RuleWalk}
+        # dispatches to this collector, and the context gate under which
+        # the walk suppresses it (loop / block bodies — see the envelope
+        # above). The legacy walk's `!in_loop_or_block` guard is now the
+        # walk's `:loop_or_block` gate, applied before `#visit`.
+        NODE_CLASSES = [Prism::IfNode, Prism::UnlessNode].freeze
+        RULE_WALK_GATES = [:loop_or_block].freeze
+
         # @return [Array<Result>] one entry per qualifying
         #   predicate. Empty when the tree carries no firing
         #   predicates.
@@ -64,17 +72,32 @@ module Rigor
           @results = []
         end
 
+        # Legacy single-collector walk — kept as the oracle the
+        # ADR-53 Track B equivalence harness compares {RuleWalk}
+        # against; deleted when Track B completes.
         def collect(root)
           walk(root, in_loop_or_block: false)
           @results.freeze
         end
 
+        # {RuleWalk} entry point: the per-node logic of the legacy walk,
+        # invoked under the same traversal contract. The `context` is
+        # unused — the loop / block suppression this collector relied on
+        # is the walk's `:loop_or_block` gate now.
+        def visit(node, _context = nil)
+          collect_predicate(node)
+        end
+
+        def results
+          @results.freeze
+        end
+
         private
 
         def walk(node, in_loop_or_block:)
           return unless node.is_a?(Prism::Node)
 
-          collect_predicate(node) if conditional_node?(node) && !in_loop_or_block
+          visit(node) if conditional_node?(node) && !in_loop_or_block
 
           child_in_loop_or_block = in_loop_or_block || enters_loop_or_block?(node)
           node.compact_child_nodes.each { |child| walk(child, in_loop_or_block: child_in_loop_or_block) }

data/lib/rigor/analysis/check_rules/dead_assignment_collector.rb

@@ -36,6 +36,15 @@ module Rigor
       #   implicit return treats `def foo; x = 1; end` as
       #   returning `1`, so the trailing write is intentional.
       class DeadAssignmentCollector
+        # ADR-53 Track B — the node classes the shared {RuleWalk}
+        # dispatches to this collector. The legacy walk visits EVERY
+        # `DefNode` (it descends into all of them, nested defs included,
+        # processing each separately — `gather_*` barrier at nested defs
+        # so an outer def never sees an inner def's locals), so the
+        # collector needs no context gate: it fires at every `def` the
+        # shared full DFS reaches, exactly like the legacy walk.
+        NODE_CLASSES = [Prism::DefNode].freeze
+
         # Returns `Array<{def_class:, def_name:, write_node:}>`
         # — one entry per dead-assignment write. Empty when
         # the tree has no qualifying writes.
@@ -44,11 +53,27 @@ module Rigor
           @results = []
         end
 
+        # Legacy single-collector walk — kept as the oracle the ADR-53
+        # Track B equivalence harness compares {RuleWalk} against; deleted
+        # when Track B completes.
         def collect(root)
           walk_for_def_nodes(root)
           @results.freeze
         end
 
+        # {RuleWalk} entry point: the legacy walk's per-`def` logic,
+        # invoked at every `def` under the shared traversal contract. The
+        # `context` is unused — this collector processes all defs.
+        def visit(def_node, _context = nil)
+          collect_def_assignments(def_node)
+        end
+
+        # The accumulated result, frozen the same way `#collect` returns
+        # it — used by {RuleWalk}-driven callers after the walk completes.
+        def results
+          @results.freeze
+        end
+
         private
 
         def walk_for_def_nodes(node)

data/lib/rigor/analysis/check_rules/ivar_write_collector.rb

@@ -31,6 +31,18 @@ module Rigor
         BARRIER_NODES = [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode].freeze
         private_constant :BARRIER_NODES
 
+        # ADR-53 Track B — the node classes the shared {RuleWalk}
+        # dispatches to this collector, and the context gate under which
+        # the walk suppresses it. The legacy walk descends only through
+        # class / module bodies and `return`s at the first `def` it meets,
+        # so it collects ivar writes only from a `def` that sits directly
+        # in a class / module body, never one nested in another `def`. On
+        # the shared full DFS that prune becomes the `:inside_def` gate;
+        # the enclosing class / module name stack the legacy walk threaded
+        # as `qualified_prefix` is now `context.qualified_prefix`.
+        NODE_CLASSES = [Prism::DefNode].freeze
+        RULE_WALK_GATES = [:inside_def].freeze
+
         # Returns `Hash[class_name (String) => Hash[ivar_name
         # (Symbol) => Array<{node:, type:}>]]`. Empty when the
         # tree has no qualifying writes.
@@ -39,11 +51,28 @@ module Rigor
           @accumulator = {}
         end
 
+        # Legacy single-collector walk — kept as the oracle the ADR-53
+        # Track B equivalence harness compares {RuleWalk} against; deleted
+        # when Track B completes.
         def collect(root)
           walk(root, [])
           @accumulator.transform_values(&:freeze).freeze
         end
 
+        # {RuleWalk} entry point: the legacy walk's per-`def` logic,
+        # invoked at each class-/module-body `def` under the shared
+        # traversal contract. `collect_def_writes`' verbatim body reads the
+        # enclosing class prefix from `context.qualified_prefix`.
+        def visit(def_node, context)
+          collect_def_writes(def_node, context.qualified_prefix)
+        end
+
+        # The accumulated result, frozen the same way `#collect` returns
+        # it — used by {RuleWalk}-driven callers after the walk completes.
+        def results
+          @accumulator.transform_values(&:freeze).freeze
+        end
+
         private
 
         def walk(node, qualified_prefix)