rigortype 0.4.6 → 0.4.8

data/lib/rigor/configuration.rb

@@ -62,6 +62,10 @@ module Rigor
       "disable" => [],
       "libraries" => [],
       "signature_paths" => nil,
+      # Issue #2517 — a core signature directory loaded IN PLACE OF the `rbs` gem's `core/` (a provider such as
+      # rbs-shifter writes one for an older CRuby). `nil` (the default) loads the gem's core. Unlike
+      # `signature_paths:`, which only adds, this replaces: the default core is not loaded beside it.
+      "core_root" => nil,
       # The project's test roots: the directories (or files) holding its tests. `nil` (the default) auto-detects
       # whichever of `spec/` and `test/` exist, the same way `signature_paths: nil` auto-detects `sig/`; `[]`
       # declares that the project has none. `rigor sig-gen --params=observed` harvests call-site observations
@@ -77,10 +81,9 @@ module Rigor
         "inline_declared" => "write"
       },
       # ADR-17 — project-side monkey-patch pre-evaluation. Empty by default; users opt in by listing explicit
-      # files that the analyzer walks before per-file inference so patched-method declarations are visible
-      # across the project (e.g. `lib/core_ext/string_extensions.rb`). Slice 1 plumbing only — listed files
-      # are validated at config-load time (`pre-eval.file-not-found` on a missing path), but the dispatcher
-      # tier consuming the registry lands in slice 2.
+      # files (or globs) that the analyzer walks before per-file inference so patched-method declarations are
+      # visible across the project (e.g. `lib/core_ext/string_extensions.rb`). A missing literal path surfaces
+      # as `pre-eval.file-not-found`.
       "pre_eval" => [],
       # ADR-22 — baseline file path. nil (default) means no baseline is loaded; the `false` literal is
       # treated as the explicit-disable form for `.rigor.yml`-side override of an upstream `.rigor.dist.yml`
@@ -209,8 +212,8 @@ module Rigor
         # set up with `rbs collection install`, the resulting `rbs_collection.lock.yaml` carries the resolved
         # (gem, version, source) triples and `.gem_rbs_collection/` holds the downloaded `.rbs` files. Rigor
         # parses the lockfile and auto-feeds each gem's `<collection_root>/<name>/<version>/` directory into
-        # `RbsLoader`'s `signature_paths:`. Sources of type `stdlib` are skipped because rigor's bundled
-        # `DEFAULT_LIBRARIES` already covers that surface.
+        # `RbsLoader`'s `signature_paths:`. Sources of type `stdlib` install no directory; issue #2946 — they
+        # load as RBS libraries, appended to `DEFAULT_LIBRARIES + libraries:`, as the `rbs` CLI loads them.
         #
         # `lockfile:` (String, optional): explicit path to `rbs_collection.lock.yaml`. Resolved relative to
         # the project root when relative.
@@ -229,6 +232,11 @@ module Rigor
     PATH_KEYS = %w[paths signature_paths test_paths pre_eval].freeze
     private_constant :PATH_KEYS
 
+    # The single-path sibling of {PATH_KEYS}: resolved the same way, but kept a String rather than wrapped in an
+    # Array.
+    SCALAR_PATH_KEYS = %w[core_root].freeze
+    private_constant :SCALAR_PATH_KEYS
+
     # Top-level keys this implementation DECLARES but never reads — see `docs/internal-spec/config.md`
     # § "Reserved namespaces" and ADR-99.
     #
@@ -271,7 +279,8 @@ module Rigor
 
     attr_reader :target_ruby, :paths, :exclude_patterns, :plugins, :cache_path, :cache_max_bytes,
                 :cache_validation, :disabled_rules,
-                :libraries, :signature_paths, :test_paths, :fold_platform_specific_paths, :parameter_inference,
+                :libraries, :signature_paths, :core_root, :test_paths, :fold_platform_specific_paths,
+                :parameter_inference,
                 :plugins_isolation,
                 :plugins_io_network, :plugins_io_allowed_paths,
                 :plugins_io_allowed_url_hosts,
@@ -352,7 +361,8 @@ module Rigor
     # [PHPStan](https://phpstan.org/config-reference#paths).
     def self.load(path = nil)
       resolved = path || discover
-      if resolved.nil? || !File.exist?(resolved)
+      loaded = resolved && File.exist?(resolved) ? resolved : nil
+      if loaded.nil?
         data = DEFAULTS
         effects_key_present = false
         target_ruby_key_present = false
@@ -361,13 +371,14 @@ module Rigor
         # `DEFAULTS` itself carries an `"effects" => false` entry: once merged, "the file never wrote
         # `effects:`" and "the file wrote `effects: false`" collapse to the same value and become
         # indistinguishable to {#initialize}. This is the only place that distinction still exists.
-        raw = load_with_includes(resolved)
+        raw = load_with_includes(loaded)
         effects_key_present = raw.key?("effects")
         target_ruby_key_present = raw.key?("target_ruby")
         data = DEFAULTS.merge(raw)
       end
       new(autowire_default_plugins(data), effects_key_present, target_ruby_key_present || false)
-        .with_exclude_base(resolved && File.exist?(resolved) ? File.dirname(resolved) : nil)
+        .with_exclude_base(loaded && File.dirname(loaded))
+        .with_config_path(loaded)
     end
 
     # #1576 — the directory relative `exclude:` patterns are matched against: the directory of the config file in
@@ -376,6 +387,17 @@ module Rigor
       @base_dir || Dir.pwd
     end
 
+    # Issue #2742 — the path config-anchored diagnostics are positioned at: the loaded config file's path
+    # relative to the working directory (the project-root convention {Analysis::Baseline} uses), or
+    # `.rigor.yml` when no file was loaded. A `--config=config/rigor.yml` run names `config/rigor.yml`.
+    def config_display_path
+      return DEFAULT_PATH if @config_path.nil?
+
+      Pathname.new(@config_path).relative_path_from(Pathname.new(Dir.pwd)).to_s
+    rescue ArgumentError
+      @config_path
+    end
+
     # ADR-93 WD2 — the one bundled plugin default-wired without a `plugins:` entry. `rigor-rbs-inline` is the
     # gem; `rbs-inline` is its manifest id (the loader raises on a duplicate id, so both forms count as
     # "already listed").
@@ -490,6 +512,7 @@ module Rigor
 
       out = data.dup
       PATH_KEYS.each { |key| resolve_path_key!(out, key, base_dir) }
+      SCALAR_PATH_KEYS.each { |key| resolve_scalar_path_key!(out, key, base_dir) }
       resolve_plugins_io_paths!(out, base_dir)
       out
     end
@@ -500,6 +523,12 @@ module Rigor
       out[key] = Array(out[key]).map { |p| ConfigPath.absolute(p.to_s, base_dir) }
     end
 
+    def self.resolve_scalar_path_key!(out, key, base_dir)
+      return unless out.key?(key) && out[key].is_a?(String)
+
+      out[key] = ConfigPath.absolute(out[key], base_dir)
+    end
+
     def self.resolve_plugins_io_paths!(out, base_dir)
       plugins_io = out["plugins_io"]
       return unless plugins_io.is_a?(Hash) && plugins_io["allowed_paths"]
@@ -582,6 +611,7 @@ module Rigor
       @libraries = Array(data.fetch("libraries", DEFAULTS.fetch("libraries"))).map(&:to_s).freeze
       sig_paths = data.fetch("signature_paths", DEFAULTS.fetch("signature_paths"))
       @signature_paths = sig_paths.nil? ? nil : Array(sig_paths).map(&:to_s).freeze
+      @core_root = coerce_core_root(data.fetch("core_root", DEFAULTS.fetch("core_root")))
       test_paths = data.fetch("test_paths", DEFAULTS.fetch("test_paths"))
       @test_paths = test_paths.nil? ? nil : Array(test_paths).map(&:to_s).freeze
       @sig_gen_inline_declared = coerce_sig_gen_inline_declared(data.fetch("sig_gen", nil))
@@ -595,18 +625,13 @@ module Rigor
       # ADR-67 WD6a — resolve to a strict Boolean so a truthy non-`true` value (e.g. a stray String) does not
       # silently enable the gate; only the literal `true` activates the check-walk collector pre-pass.
       @parameter_inference = data.fetch("parameter_inference", DEFAULTS.fetch("parameter_inference")) == true
-      # Resolved before `@effects` — ADR-103 WD15's "effects-on-by-default" reads {#bleeding_edge_active?},
-      # which reads `@bleeding_edge_active_ids`.
-      @bleeding_edge = coerce_bleeding_edge(
-        data.fetch("bleeding_edge", DEFAULTS.fetch("bleeding_edge"))
-      )
-      @bleeding_edge_severity_overrides = BleedingEdge.severity_overrides_for(@bleeding_edge)
-      @bleeding_edge_active_ids = BleedingEdge.active_ids_for(@bleeding_edge)
       # ADR-103 WD13 — presence, not truthiness: `effects:` written with no body parses as nil and still
-      # means "on", so the key's presence in the loaded data is what {#effects_enabled?} reads.
-      @effects = coerce_effects(data, effects_key_present: effects_key_present)
-      coerce_effects_snapshot(@effects)
-      coerce_effects_policy(@effects)
+      # means "on", so the key's presence in the loaded data is what {#effects_enabled?} reads. The raw
+      # input is kept so {#with_bleeding_edge} re-derives the effects block from the same source.
+      @effects_key_present = effects_key_present
+      @effects_written = Ractor.make_shareable(data.fetch("effects", false))
+      derive_bleeding_edge(data.fetch("bleeding_edge", DEFAULTS.fetch("bleeding_edge")))
+      derive_effects
       @cache_path = cache.fetch("path").to_s
       raw_max = cache.fetch("max_bytes")
       @cache_max_bytes = raw_max.nil? ? nil : Integer(raw_max)
@@ -663,6 +688,10 @@ module Rigor
     def to_h # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       {
         "target_ruby" => target_ruby,
+        # Issue #2742 — the loaded file's display path is part of the resolved configuration: two files
+        # with identical bodies still anchor their config diagnostics differently, so the run-cache and
+        # incremental fingerprints must tell them apart.
+        "config_path" => config_display_path,
         # A stated `target_ruby` turns on the deprecation rules a defaulted one leaves off (#1692), so the run cache
         # key and the incremental fingerprint must tell the two apart even where the value matches.
         "target_ruby_explicit" => target_ruby_explicit?,
@@ -672,6 +701,7 @@ module Rigor
         "disable" => disabled_rules,
         "libraries" => libraries,
         "signature_paths" => signature_paths,
+        "core_root" => core_root,
         # `test_paths:` is deliberately absent, as `effects:` is: `to_h` feeds the run cache key and the
         # incremental-snapshot fingerprint, and the test roots change no diagnostic, so editing them must not
         # invalidate either. `sig_gen:` is absent for the same reason: only `rigor sig-gen` reads it.
@@ -752,15 +782,14 @@ module Rigor
     # It is a frozen `dup` with the bleeding-edge ivars re-set: `dup` returns an unfrozen shallow copy
     # (every other ivar is the receiver's deeply-frozen value, safe to share read-only), the replacements
     # are themselves deeply frozen, and the re-`freeze` keeps the result `Ractor.shareable?` for the worker
-    # path. **Every ivar `#initialize` derives from `@bleeding_edge` has to be re-derived here** — the
-    # selector, the severity map, and the active-id set the {#bleeding_edge_active?} predicate reads.
+    # path. **Every ivar `#initialize` derives from the bleeding-edge selector has to be re-derived here** — it
+    # calls the same {#derive_bleeding_edge} and {#derive_effects} that `#initialize` does, so the selector,
+    # the severity map, the active-id set and the `effects:` default (ADR-103 WD15's "effects-on-by-default")
+    # all follow the new value, and a derived ivar added to `#initialize` is picked up without a second edit.
     def with_bleeding_edge(value)
-      selector = coerce_bleeding_edge(value)
       copy = dup
-      copy.instance_variable_set(:@bleeding_edge, selector)
-      copy.instance_variable_set(:@bleeding_edge_severity_overrides,
-                                 BleedingEdge.severity_overrides_for(selector))
-      copy.instance_variable_set(:@bleeding_edge_active_ids, BleedingEdge.active_ids_for(selector))
+      copy.send(:derive_bleeding_edge, value)
+      copy.send(:derive_effects)
       copy.freeze
     end
 
@@ -772,6 +801,16 @@ module Rigor
       copy.freeze
     end
 
+    # Issue #2742 — a sibling Configuration recording which file {Configuration.load} read, so the
+    # diagnostics anchored at "the configuration" name it ({#config_display_path}). `path` is the resolved
+    # config path; nil — no file loaded, or a bare {Configuration.new} — keeps the `.rigor.yml` default.
+    # Same frozen `dup` shape as {#with_exclude_base}.
+    def with_config_path(path)
+      copy = dup
+      copy.instance_variable_set(:@config_path, path && File.absolute_path(path).freeze)
+      copy.freeze
+    end
+
     # #1777 — a sibling Configuration with only `baseline:` unset, every other field (including the
     # explicitness of `target_ruby`) shared with the receiver. `rigor baseline generate` analyses with
     # this so the generating run sees exactly the configuration `rigor check` will, minus the filter it
@@ -794,19 +833,38 @@ module Rigor
     #
     # Same `dup` + re-`freeze` shape as {#with_bleeding_edge}: every other ivar is the receiver's deeply
     # frozen value, safe to share read-only, and the result stays `Ractor.shareable?` for the worker path.
+    # The implicit block is recorded as a written empty one, so a later {#with_bleeding_edge} re-derives
+    # it instead of falling back to the absent-key default and dropping it.
     def with_effects_enabled
       return self if effects_enabled?
 
       copy = dup
-      copy.instance_variable_set(:@effects, {}.freeze)
-      # The implicit block defaults like a written one. `rigor effects` emits no diagnostic either way,
-      # but the two configurations must not differ in a field a later reader could branch on.
-      copy.instance_variable_set(:@effects_check, true)
+      copy.instance_variable_set(:@effects_key_present, true)
+      copy.instance_variable_set(:@effects_written, {}.freeze)
+      copy.send(:derive_effects)
       copy.freeze
     end
 
     private
 
+    # ADR-50 § WD2 / ADR-103 WD15 — derives the bleeding-edge selector and the two ivars the
+    # {#bleeding_edge_active?} predicate and the severity resolution read. `#initialize` and
+    # {#with_bleeding_edge} both call this, so there is one derivation to keep in step.
+    def derive_bleeding_edge(value)
+      @bleeding_edge = coerce_bleeding_edge(value)
+      @bleeding_edge_severity_overrides = BleedingEdge.severity_overrides_for(@bleeding_edge)
+      @bleeding_edge_active_ids = BleedingEdge.active_ids_for(@bleeding_edge)
+    end
+
+    # ADR-103 WD13 / WD15 — derives the `effects:` block and its snapshot and policy ivars from the raw
+    # `effects:` input the instance kept (`@effects_written`, `@effects_key_present`). The effects-on-by-default
+    # default reads the active-id set, so {#derive_bleeding_edge} must run first.
+    def derive_effects
+      @effects = coerce_effects(@effects_written, effects_key_present: @effects_key_present)
+      coerce_effects_snapshot(@effects)
+      coerce_effects_policy(@effects)
+    end
+
     # ADR-103 WD13 — the `effects:` block, or nil when the key is absent or explicitly `false`. A
     # present-but-empty key (`effects:` alone, which YAML parses as nil) and `effects: {}` are the same
     # thing: collection on, every sub-key defaulted. A non-Hash body is normalised to `{}` rather than
@@ -818,8 +876,7 @@ module Rigor
     # as `effects: {}` when the "effects-on-by-default" bleeding-edge feature is adopted. An explicit
     # `effects: false` — `effects_key_present == true` — always stays off regardless of the feature, and a
     # written block always wins outright: the feature can only fill an *absence*.
-    def coerce_effects(data, effects_key_present:)
-      value = data.fetch("effects", false)
+    def coerce_effects(value, effects_key_present:)
       return {}.freeze if value == false && !effects_key_present && effects_forced_on_by_bleeding_edge?
       return nil if value == false
 
@@ -1054,7 +1111,7 @@ module Rigor
       end
     end
 
-    # `target_ruby` is passed to `Prism.parse_file(path, version:)` at the analyser's three parse sites
+    # `target_ruby` is passed as Prism's `version:` option at the analyser's parse sites
     # (`Analysis::Runner`, `CLI::TypeOfCommand`, `CLI::TypeScanCommand`) so projects that target an older
     # Ruby get parse errors for syntax their target doesn't support. Format validation here is loose —
     # accepts any `<major>.<minor>` or `<major>.<minor>.<patch>` form, plus the literal `"latest"`. Prism
@@ -1097,6 +1154,18 @@ module Rigor
     # ADR-22 WD2 (b) — `baseline: <path>` activates the file; `baseline: false` is the explicit-disable form
     # (useful in `.rigor.yml` to override an upstream `.rigor.dist.yml` that names a baseline). `nil`
     # (default / absent key) is also "no baseline".
+    # Issue #2517 — the directory's existence and contents are checked where the environment is built
+    # ({Environment::CoreRoot.validate!}), not here: `rigor init`, `rigor doctor` and the language server's reload
+    # load a configuration without building an environment, and must still be able to read one naming a core that
+    # is not generated yet.
+    def coerce_core_root(value)
+      return nil if value.nil?
+      raise ConfigurationError, "core_root must be a directory path, got #{value.inspect}" unless value.is_a?(String)
+      raise ConfigurationError, "core_root must not be empty" if value.strip.empty?
+
+      value.dup.freeze
+    end
+
     def coerce_baseline_path(value)
       return nil if value.nil? || value == false
 

data/lib/rigor/effects/collector.rb

@@ -2,6 +2,7 @@
 
 require_relative "../type"
 require_relative "../inference/origin_lookup"
+require_relative "../typing_state"
 require_relative "attribution"
 require_relative "envelope_index"
 require_relative "file_collection"
@@ -24,8 +25,26 @@ module Rigor
     # `dynamic_origins` cause the typer already recorded. With no `effects:` block nothing calls
     # {collect_for}, `@active_count` stays zero, and `rigor check` is byte-identical.
     module Collector
-      KEY = :__rigor_effects_collector__
-      private_constant :KEY
+      # ADR-129 WD1 — the installed accumulator is a Frame whose contents are a Resource; only {record_root} touches it
+      # now, and the call-site decisions are the bound Table {CALLS}. The activation count below is a process switch,
+      # outside the typing state (WD5).
+      ACCUMULATOR = TypingState.frame(
+        :effects_collector,
+        contents: :resource, reason: "the accumulator a file's collection installs; each call site records into it",
+        # G1′ witness: `Collector.record_call` reads it during typing, so it is not a never-reads switch.
+        witness: "spec/fixtures/typing_state_witnesses/effects_collector.rb"
+      )
+      private_constant :ACCUMULATOR
+
+      # ADR-129 WD1 — the per-file call-site decisions are a bound Table: each installed accumulator's `calls` is one of
+      # its stores, journaled while a capture is open so a later `type_of` memo can validate the reads and replay the
+      # writes. The root ({record_root}) stays a touch of the accumulator: it is set once per file, before typing.
+      CALLS = TypingState.table(
+        :effects_calls,
+        bound: true,
+        reason: "node => CallRecord per file accumulator; first write wins, and a re-query reads the pinned decision"
+      )
+      private_constant :CALLS
 
       # What one call site decided, as the typer saw it.
       #
@@ -97,17 +116,18 @@ module Rigor
       # site imports must not depend on which process typed the file.
       def collect_for(path, attribution: Attribution.empty, envelopes: EnvelopeIndex.empty,
                       plugin_facts: PluginFacts.empty, unit_key: nil, unit_owner: nil)
-        previous = Thread.current[KEY]
         accumulator = Accumulator.new(path.to_s, attribution: attribution, envelopes: envelopes,
                                                  plugin_facts: plugin_facts, unit_key: unit_key,
                                                  unit_owner: unit_owner)
-        Thread.current[KEY] = accumulator
-        @mutex.synchronize { @active_count += 1 }
-        yield
-        build(accumulator)
-      ensure
-        Thread.current[KEY] = previous
-        @mutex.synchronize { @active_count -= 1 }
+        TypingState.current.with(ACCUMULATOR, accumulator) do
+          @mutex.synchronize { @active_count += 1 }
+          begin
+            yield
+            build(accumulator)
+          ensure
+            @mutex.synchronize { @active_count -= 1 }
+          end
+        end
       end
 
       def active?
@@ -117,8 +137,12 @@ module Rigor
       # The parsed root of the file being analyzed. Recorded by the analysis body once the parse is known
       # to have succeeded, so the scan runs over exactly what the typer saw.
       def record_root(root)
-        accumulator = Thread.current[KEY]
-        accumulator.root = root if accumulator && accumulator.root.nil?
+        state = TypingState.current
+        accumulator = state[ACCUMULATOR]
+        return unless accumulator
+
+        state.touch(ACCUMULATOR)
+        accumulator.root = root if accumulator.root.nil?
       end
 
       # One call site's dispatch decision. `receiver` is the type the typer computed for the receiver and
@@ -127,30 +151,38 @@ module Rigor
       # The `scope.source_path` guard matters: inter-procedural inference re-types a *callee's* body while
       # the caller's file is being analyzed, and those nodes belong to the callee's own file collection.
       def record_call(node, receiver, scope)
-        accumulator = Thread.current[KEY]
+        state = TypingState.current
+        accumulator = state[ACCUMULATOR]
         return if accumulator.nil? || accumulator.path != scope.source_path
+
         # First write wins, so a re-query has nothing to add — and asking here rather than inside
         # {Accumulator#record} is what stops it paying for the `Data` and the origin lookup below.
+        calls = accumulator.calls
+        state.log_bound_read(CALLS, calls, node, calls.fetch(node, TypingState::ABSENT)) if state.capturing?
         return if accumulator.recorded?(node)
 
         dynamic = dynamic_receiver?(receiver)
         class_name, kind = descriptor_for(receiver)
-        accumulator.record(
-          node,
-          CallRecord.new(
-            receiver_class: class_name, kind: kind, dynamic: dynamic,
-            cause: dynamic ? Inference::OriginLookup.origin_for(scope, node.receiver)&.to_s : nil,
-            resolved: true
-          )
+        call_record = CallRecord.new(
+          receiver_class: class_name, kind: kind, dynamic: dynamic,
+          cause: dynamic ? Inference::OriginLookup.origin_for(scope, node.receiver)&.to_s : nil,
+          resolved: true
         )
+        accumulator.record(node, call_record)
+        state.log_bound_write(CALLS, calls, node, call_record, TypingState::ABSENT)
       end
 
       # The typer's fallback verdict: no tier resolved this call.
       def record_unresolved(node, source_path)
-        accumulator = Thread.current[KEY]
+        state = TypingState.current
+        accumulator = state[ACCUMULATOR]
         return if accumulator.nil? || accumulator.path != source_path
 
+        calls = accumulator.calls
+        existing = calls.fetch(node, TypingState::ABSENT)
+        state.log_bound_read(CALLS, calls, node, existing)
         accumulator.mark_unresolved(node)
+        state.log_bound_write(CALLS, calls, node, calls[node], existing) unless TypingState::ABSENT.equal?(existing)
       end
 
       # The class a receiver type projects to, as `[class_name, kind]`. A deliberately small mirror of the

data/lib/rigor/effects/definition_context.rb

@@ -58,11 +58,9 @@ module Rigor
         node.is_a?(Prism::SingletonClassNode) || (node.is_a?(Prism::CallNode) && node.block.is_a?(Prism::BlockNode))
       end
 
-      # A class body.
       CLASS_BODY = of(:class, false)
       # A `class << self` body: `self` and the definee are both the singleton class.
       SINGLETON_CLASS_BODY = of(:singleton_class, true)
-      # The body of an instance method of the class.
       INSTANCE_METHOD_BODY = of(:instance, false)
       # The top level, where `self` is `main`, an instance of `Object`, and a `def` defines `Object#m`.
       TOP_LEVEL = INSTANCE_METHOD_BODY

data/lib/rigor/effects/envelope.rb

@@ -8,7 +8,7 @@ module Rigor
     # An author-declared upper bound on one method's effect labels (ADR-103 WD1; normative in
     # `docs/type-specification/effect-labels.md` § Effect envelopes).
     #
-    # Four facts and one seam:
+    # Its facts:
     #
     # - {#owner_key} — the method key the envelope binds (`Class#m` / `Class.m`). A class-level
     #   envelope is read once and {#rebind}ed onto each method of that class discovery knows.

data/lib/rigor/effects/framework_units.rb

@@ -69,7 +69,7 @@ module Rigor
       VALIDATION_TRIGGERS = %w[valid? invalid? validate!].freeze
       SINGLETON_SAVE_TRIGGERS = %w[create create!].freeze
 
-      # `initialize` is not a mailer action, and neither is a method a plugin would want double-counted.
+      # `initialize` is not a mailer action.
       NON_ACTION_METHODS = %w[initialize].to_set.freeze
 
       module_function

data/lib/rigor/effects/mutation_classifier.rb

@@ -32,13 +32,10 @@ module Rigor
       # `foo=`, and deliberately not `==` / `<=` / `!=` / `===`.
       ATTRIBUTE_WRITER = /\A[a-z_][A-Za-z0-9_]*=\z/
 
-      # Every Hash method that mutates its receiver. The widening keeps two tables because they answer two different
-      # questions of a `HashShape` — `MutationWidening::HASH_MUTATORS` changes the pair set,
-      # `HashLookupMutation::MUTATORS` changes what a read of the pairs answers — but either is a write to the
-      # receiver, and that is all this asks: `h.compare_by_identity` raises `FrozenError` on a frozen hash as
-      # `h.clear` does (unless the hash already compares by identity, when it returns before the check), and a
-      # method whose one effect was `@h.compare_by_identity` did not read as mutating while this cited the first
-      # table alone.
+      # Every Hash method that mutates its receiver: the union of two widening tables that answer different
+      # questions of a `HashShape` (the pair set; what a read of the pairs answers). Either is a write to the
+      # receiver, so either counts. `compare_by_identity` lives only in the second, and it raises `FrozenError`
+      # on a frozen hash as `h.clear` does, so a method whose one effect is that call must still read as mutating.
       #
       # `rehash` is in neither table because it changes no read a shape can state: a shape's keys are literals, which
       # a rebuild never merges. It still rebuilds the receiver's table in place, and it is the one name spelt here.

data/lib/rigor/effects/propagator.rb

@@ -363,7 +363,7 @@ module Rigor
         # dispatch target is spelled under a different key, and this is the rewrite: the same ancestor walk
         # {#resolve_owner} performs, on the instance side, for `initialize`.
         #
-        # Three boundaries, and each of them can only narrow:
+        # Four boundaries, and each of them can only narrow:
         #
         # - a project `def self.new` **wins**. It is the definition `Const.new` actually reaches, and a
         #   constructor that overrides `new` is the case where `#initialize` is not the answer. Resolved

data/lib/rigor/effects/registry.rb

@@ -35,8 +35,8 @@ module Rigor
       # without proposing an unrelated label for a genuinely new spelling.
       SUGGESTION_DISTANCE_CAP = 2
 
-      # The shared registry as shipped. Memoised: the YAML parse is a once-per-process cost, and
-      # nothing consumes the registry yet, so it stays lazy rather than paying at `require "rigor"`.
+      # The shared registry as shipped. Memoised: the YAML parse is a once-per-process cost, so it stays
+      # lazy rather than paying at `require "rigor"`.
       def self.default
         @default ||= load_file(DATA_PATH)
       end

data/lib/rigor/effects/snapshot.rb

@@ -55,7 +55,7 @@ module Rigor
       #
       # A count rather than the causes themselves (#434). On redmine the cause renderings were 144,771 of
       # the file's 293,276 bytes, on lines up to 821 characters — simultaneously the half a reviewer
-      # cannot read and the half that churns when an unrelated call moves. This file already makes that
+      # cannot read and the half that churns when an unrelated call moves. {SnapshotDiff} already makes that
       # argument about origins ("a record keyed by them would churn on every refactor"); the causes are
       # the same class of thing and were the one place it was not applied. What a reviewer needs from the
       # record is the stable fact that the row is not exhaustive and by how much, which is what a count

data/lib/rigor/effects/taint_cause.rb

@@ -8,8 +8,6 @@ module Rigor
     # A tainted summary reads "these effects, and possibly more": the cause says which knowledge the
     # analyzer could not have. Taint never produces a finding — diagnostics read the proven lane
     # only — so this enum is a reporting vocabulary, not a diagnostic one.
-    #
-    # Nothing produces causes yet; the collector of #379 is the first writer.
     module TaintCause
       # Closed and ordered by how it arises: dispatch the analyzer could not resolve first, then
       # attribution it had to take on trust, then the collector's own limits.

data/lib/rigor/effects/unit_scan.rb

@@ -586,9 +586,9 @@ module Rigor
       # #1071 widens the answer per `respond_to` arm: a unit that spelled a dispatcher renders one
       # conventional `<action>.<fmt>` template per arm rather than one `<action>.html`, so the row is
       # applied once per arm the walk read, each answered outright (a `responds:` row at the arm's own
-      # top level) or degenerate (`any` / `all`) standing its arm's edge down. The `<action>.html`
-      # answer survives only for a dispatcher the walk could not name arms on, or one nested under a
-      # branch — the plain fall-through still exists on the path that skips it.
+      # top level) or degenerate (`any` / `all`) standing its arm's edge down. The `<action>.html` answer
+      # is kept where no arm was read, and beside the arms when the dispatcher is nested under a branch,
+      # because the plain fall-through still exists on the path that skips it.
       def apply_unit_callees
         return if @responded || @singleton || @non_public
         return if @owner_class.nil? || @method_name.nil?
@@ -811,11 +811,9 @@ module Rigor
       #
       # **Unless the syntax named the class** (#463). The `Dynamic` exclusion exists because a projected
       # receiver class is a guess; a written constant path is not one, and {#catalog_target} already
-      # trusts it for the row lookup. Refusing the posture there made the catalogue's reach a function of
-      # whether the bundled rbs happens to ship a signature for the constant: `Net::HTTP.get` proves
-      # `io.net.http` and `Net::IMAP.new` proved nothing, because rbs ships `net-http` and not
-      # `net-imap`. That is why the `Net::FTP` row has never once fired, and why Redmine's IMAP and POP3
-      # pollers proved no network at all.
+      # trusts it for the row lookup. Refusing the posture there made the catalogue's reach depend on
+      # whether the bundled rbs ships a signature for the constant: `Net::HTTP.get` proved `io.net.http`,
+      # while `Net::IMAP.new` proved nothing, because rbs ships `net-http` and not `net-imap`.
       #
       # The site is then **claimed**, and so discharges, like every other catalogue answer. That is not a
       # softening of the `dynamic-receiver` rule but its premise failing: the taint says the class the
@@ -974,12 +972,10 @@ module Rigor
         positional_arity(node).positive?
       end
 
-      # The class the catalogue would look this call up under, as `[owner, singleton, implicit_self]`.
+      # The class the catalogue would look this call up under, as `[owner, singleton, implicit, named]`.
       # Spelled from the syntax where the syntax settles it and from the typer's receiver otherwise;
-      # `[nil, …]` when neither does.
-      # `[owner, singleton, implicit, named]`. `named` says the owner came from a **constant path the
-      # author wrote**, which is what licenses the posture on a receiver the typer could not resolve
-      # ({#posture_allowed?}).
+      # `[nil, …]` when neither does. `named` says the owner came from a **constant path the author wrote**,
+      # which is what licenses the posture on a receiver the typer could not resolve ({#posture_allowed?}).
       def catalog_target(node, record)
         receiver = node.receiver
         return ["Kernel", false, true, false] if receiver.nil? || receiver.is_a?(Prism::SelfNode)