rigortype 0.3.8 → 0.4.0

data/lib/rigor/analysis/reachability/graph.rb

@@ -29,13 +29,11 @@ module Rigor
         # bucket on trust.
         Undecidable = Data.define(:fqn, :path, :line, :reason)
 
-        # @param declarations [Array<Scan::Declaration>]
-        # @param references [Array<Scan::Reference>]
-        # @param root_fqns [Enumerable<String>] declarations that are entry points regardless of who references
+        # @param root_fqns — declarations that are entry points regardless of who references
         #   them (config-declared globs in this slice; plugin-supplied roots are #349).
-        # @param foreign [#call] predicate answering "is this FQN owned by something outside the project?" —
+        # @param foreign — predicate answering "is this FQN owned by something outside the project?" —
         #   a reopened gem or stdlib class must never be a candidate (WD6). Defaults to "nothing is foreign".
-        # @param dynamic_uses [Array<Scan::DynamicUse>] sites where a constant is reached by name at runtime.
+        # @param dynamic_uses — sites where a constant is reached by name at runtime.
         #   A literal-argument site contributes a real reference; a dynamic one taints a namespace (WD4).
         def initialize(declarations:, references:, root_fqns: [], dynamic_uses: [], foreign: ->(_fqn) { false })
           @declarations = declarations

data/lib/rigor/analysis/reachability/plugin_roots.rb

@@ -83,14 +83,14 @@ module Rigor
         # Loads the project's configured plugins, runs every `#prepare`, and returns the union of every
         # published `:reachability_roots` and `:reachability_references` fact.
         #
-        # @param configuration [Rigor::Configuration] the loaded project configuration.
-        # @param plugin_requirer [#call] how a plugin gem is brought into the process. The same seam
-        #   `Analysis::Runner` exposes, so a spec can register a plugin class without publishing a gem.
-        # @param cache_store [Rigor::Cache::Store, nil] when given, each plugin's `#prepare` producers read
+        # @param plugin_requirer — how a plugin gem is brought into the process, called with the gem name. The
+        #   same seam `Analysis::Runner` exposes, so a spec can register a plugin class without publishing a
+        #   gem.
+        # @param cache_store — when given, each plugin's `#prepare` producers read
         #   and write the same ADR-60 record-and-validate slots they use under `rigor check`, instead of
         #   recomputing from scratch — a routes parse or a factory discovery is a validated cache read on
         #   every invocation after the first. Nil keeps the historical recompute-always behaviour.
-        # @return [Contribution] sorted and de-duplicated. Empty whenever the project declares no plugins, no
+        # @return sorted and de-duplicated. Empty whenever the project declares no plugins, no
         #   plugin contributes anything, or anything at all goes wrong.
         def collect(configuration:, plugin_requirer: ->(name) { require name }, cache_store: nil)
           return Contribution.empty if configuration.plugins.empty?

data/lib/rigor/analysis/reachability/project_files.rb

@@ -46,8 +46,8 @@ module Rigor
           File.fnmatch?(pattern, path, File::FNM_PATHNAME)
         end
 
-        # @param relative_paths [Array<String>] paths relative to `root`.
-        # @return [Array<String>] those that belong to the project itself.
+        # @param relative_paths — paths relative to `root`.
+        # @return those that belong to the project itself.
         def own(relative_paths, root)
           prefixes = submodule_prefixes(root)
           relative_paths.grep_v(VENDOR_DIRS).reject { |rel| prefixes.any? { |prefix| rel.start_with?(prefix) } }

data/lib/rigor/analysis/reachability/scan.rb

@@ -70,11 +70,6 @@ module Rigor
           end
         end
 
-        # @param path [String] the file's path, as the report should render it.
-        # @param source [String] the file's bytes.
-        # @param target_ruby [String, nil] Prism version string, threaded from the project configuration.
-        # @return [Result, nil] nil when the file does not parse (a parse error is the analyzer's business, not
-        #   this scan's — it simply contributes nothing rather than half a file).
         # A constant name is ASCII by construction, so a byte sequence that is not valid UTF-8 cannot be one.
         # Dropping it is both correct and the only safe answer: carrying it forward crashed the whole run on
         # the first `String#sub` downstream, which is how this surfaced — `rigor unused` on Rigor's own
@@ -86,6 +81,11 @@ module Rigor
           name.valid_encoding? ? name : nil
         end
 
+        # @param path — the file's path, as the report should render it.
+        # @param source — the file's bytes.
+        # @param target_ruby — Prism version string, threaded from the project configuration.
+        # @return nil when the file does not parse (a parse error is the analyzer's business, not
+        #   this scan's — it simply contributes nothing rather than half a file).
         def self.call(path:, source:, target_ruby: nil)
           parsed = if target_ruby
                      Prism.parse(source, filepath: path,

data/lib/rigor/analysis/reachability/scan_cache.rb

@@ -36,6 +36,7 @@ module Rigor
           File.expand_path("scan.rb", __dir__),
           File.expand_path(__FILE__)
         ].freeze
+        Ractor.make_shareable(SOURCE_FILES)
 
         # A file modified within this window of the recording instant is computed but never
         # recorded — the FileDigest racy-write guard, one tier simpler because a refused signature
@@ -43,9 +44,9 @@ module Rigor
         RACY_WINDOW_NS = 2_000_000_000
         private_constant :RACY_WINDOW_NS
 
-        # @param cache_path [String, nil] the configuration's cache root; nil or empty is an inert
+        # @param cache_path — the configuration's cache root; nil or empty is an inert
         #   cache (every fetch computes, nothing persists).
-        # @param target_ruby [String, nil] parse-affecting configuration, part of the identity.
+        # @param target_ruby — parse-affecting configuration, part of the identity.
         def self.open(cache_path, target_ruby: nil)
           return new(path: nil, header: nil) if cache_path.nil? || cache_path.to_s.empty?
 

data/lib/rigor/analysis/reachability/signature_scan.rb

@@ -26,8 +26,8 @@ module Rigor
       module SignatureScan
         module_function
 
-        # @param file [String] path to a `.rbs` file.
-        # @return [Array<Scan::Reference>] one file-level reference per distinct referenced name. Empty when the
+        # @param file — path to a `.rbs` file.
+        # @return one file-level reference per distinct referenced name. Empty when the
         #   file cannot be read or parsed — a broken signature is the analyzer's business, not this scan's.
         def call(file)
           _, _, decls = ::RBS::Parser.parse_signature(::RBS::Buffer.new(name: file, content: File.read(file)))

data/lib/rigor/analysis/result.rb

@@ -7,7 +7,7 @@ module Rigor
     class Result
       attr_reader :diagnostics, :stats
 
-      # @param stats [Rigor::Analysis::RunStats, nil] end-of-run telemetry (target file count, RBS class
+      # @param stats — end-of-run telemetry (target file count, RBS class
       #   breakdown, wall + RSS) collected by the Runner. Nil when stats collection wasn't requested or wasn't
       #   applicable (early-exit paths like `validate_target_ruby` failure).
       def initialize(diagnostics: [], stats: nil)
@@ -43,8 +43,6 @@ module Rigor
 
       # The diagnostics {#crashed?} answers true for, so a caller can name what it saw rather than only that
       # it saw something.
-      #
-      # @return [Array<Rigor::Analysis::Diagnostic>]
       def crash_diagnostics
         diagnostics.select { |diagnostic| CrashSignature.discards_file_analysis?(diagnostic) }
       end

data/lib/rigor/analysis/rule_catalog.rb

@@ -642,7 +642,10 @@ module Rigor
             "Later write is `nil` — the `@cache = nil` clear-idiom is allowlisted.",
             "Either side is Union / Dynamic / IntegerRange / a shape-varied carrier.",
             "Writes live in different classes that happen to share an ivar name.",
-            "Writes are in `def self.foo` (singleton) bodies — those track separately."
+            "Writes are in a singleton body — `def self.foo` or a `class << self` def — those track " \
+            "separately.",
+            "Writes are in a `def` inside an anonymous-class factory block (`Class.new do … end`, " \
+            "`Module.new`, `Struct.new`, `Data.define`): that body defines another class."
           ],
           suppression: "`# rigor:disable ivar-write-mismatch` on the offending write.",
           severity_authored: :error,
@@ -653,6 +656,90 @@ module Rigor
           since: "0.1.2"
         ),
 
+        CheckRules::RULE_GLOBAL_WRITE_TYPE_MISMATCH => Entry.new(
+          id: CheckRules::RULE_GLOBAL_WRITE_TYPE_MISMATCH,
+          summary: "A special global is assigned a literal its setter rejects (TypeError at runtime).",
+          fires_when: [
+            "The write is `$g = literal` to a special whose setter checks the value: `$/` / `$-0`, `$,` and " \
+            "`$\\` (a String or nil), `$;` / `$-F` (a String, a Regexp, nil, or an object with `to_str`), `$~` " \
+            "(a MatchData or nil), `$0` / `$PROGRAM_NAME` (a String or an object with `to_str`), `$.` (an " \
+            "Integer, a Float, or an object with `to_int`), `$-i` (a String, nil, false, or an object with " \
+            "`to_str`), and `$stdout` / `$>` / `$stderr` (an object that responds to `write`, ADR-117 WD2).",
+            "The value is a literal node — an Integer, Float, Rational or imaginary literal, a String, Symbol " \
+            "or Regexp literal (interpolated or not), an Array or Hash literal, or `nil` / `true` / `false`, " \
+            "parenthesised or not — whose class the setter does not take: `$/ = 1`, `$/ = /x/`, `$~ = \"x\"`, " \
+            "`$0 = nil`, `$. = \"3\"`, `$stdout = 1`.",
+            "Where the setter also converts (`to_str`, `to_int`) or asks for `write`, the literal's object " \
+            "cannot answer that method: RBS gives its class neither the method nor a `method_missing` / " \
+            "`respond_to_missing?` / `respond_to?` of its own, and the program defines none of them anywhere.",
+            "The envelope is the interpreter's setter, not the global's RBS declaration: `$/ = /x/` fires " \
+            "although `$;` takes a Regexp."
+          ],
+          does_not_fire_when: [
+            "The special's setter accepts every value: `$stdin` (never checked, ADR-117 WD2), `$_`, `$VERBOSE`, " \
+            "`$DEBUG`, `$=`; nor `$@`, whose setter depends on whether `$!` is set.",
+            "The value is not a literal — a variable, a method call, a constant, a conditional — whatever its " \
+            "inferred type: a class RBS declares without `write` or `to_str` does not prove the object lacks it.",
+            "RBS gives the literal's class the method or a hatch of its own (a `sig/` reopening or `include` " \
+            "counts).",
+            "The program — any project or `pre_eval:` file — defines the method or a `method_missing` / " \
+            "`respond_to_missing?` / `respond_to?` anywhere, in any spelling (`def`, `define_method`, " \
+            "`define_singleton_method`, `alias`, `alias_method`, `attr_*`, a delegation macro, a string `eval`, " \
+            "the same through `send`) and on any receiver, or defines a method whose name no literal spells (a " \
+            "computed `define_method` or `send` name, a string `eval` whose code is not a plain literal, a name " \
+            "whose bytes are not valid in its encoding). " \
+            "This is blanket: no census of where a definition lands can be complete, so the literal of every " \
+            "class declines, whatever the definition's owner.",
+            "An ancestor's surface is rewritten from outside (`Integer.include(M)`, `Object.include(M)`, a string " \
+            "`class_eval`), or a top-level `include` / `prepend` / `extend`, or an ancestor's `include`, names a " \
+            "module RBS does not rule out.",
+            "For `$stdout` / `$>` / `$stderr`, a refinement that may add `write`, to any class, and a `using` in " \
+            "effect at the write. Which class it refines is not followed. The `to_str` / `to_int` conversions, and a " \
+            "refined `respond_to_missing?` / `respond_to?`, ignore refinements, so those still fire.",
+            "Any project or `pre_eval:` file aliases the special (`alias $stdout $out`, on either side).",
+            "The write is `$g op= v`, `$g ||= v`, `$g &&= v`, a multiple-assignment target, a `for` index, or a " \
+            "`rescue => $g` reference: their value is not type-checked.",
+            "The write sits in the dead arm of a decidable version guard. Other code that never runs (`if " \
+            "false`, after `return`) is not recognised, and a write there still fires."
+          ],
+          suppression: "`# rigor:disable global.write-type-mismatch` on the write.",
+          severity_authored: :error,
+          severity_by_profile: { lenient: :warning, balanced: :error, strict: :error },
+          # A literal's class is exact, the setter's envelope is the running interpreter's, and every way a program can
+          # give the object the method the setter asks for declines; the write then raises every time it runs.
+          evidence_tier: :high,
+          since: "0.4.0"
+        ),
+
+        CheckRules::RULE_GLOBAL_READONLY_WRITE => Entry.new(
+          id: CheckRules::RULE_GLOBAL_READONLY_WRITE,
+          summary: "A read-only special global is written (NameError at runtime).",
+          fires_when: [
+            "The write is `$g = value`, `$g op= value`, or a target of a multiple assignment (`$g, x = ...`, " \
+            "`*$g`) — forms that always write — to a special Ruby defines read-only: `$!`, `$$`, `$?`, `$<`, " \
+            "`$FILENAME`, `$*`, `$:` / `$LOAD_PATH` / `$-I`, `$\"` / `$LOADED_FEATURES`, `$-W`, `$-p`, `$-l`, " \
+            "`$-a`.",
+            "Whatever the value: the setter raises `NameError` (`$! is a read-only variable`) before it " \
+            "looks at it."
+          ],
+          does_not_fire_when: [
+            "The write is `$g ||= v` or `$g &&= v`, which writes only when the current value is falsy " \
+            "(truthy): `$LOAD_PATH ||= []` never writes.",
+            "The write is a `for` index or a `rescue => $g` reference.",
+            "Any project or `pre_eval:` file aliases the special (`alias $! $err`, on either side), which can " \
+            "make the name another variable.",
+            "Mutating the value is not a write: `$LOAD_PATH << dir` and `$LOADED_FEATURES.delete(f)` stay silent.",
+            "The write sits in the dead arm of a decidable version guard. Other code that never runs is not " \
+            "recognised, and a write there still fires."
+          ],
+          suppression: "`# rigor:disable global.readonly-write` on the write.",
+          severity_authored: :error,
+          severity_by_profile: { lenient: :error, balanced: :error, strict: :error },
+          # Syntactic: the name alone decides it, and the write raises every time it runs.
+          evidence_tier: :high,
+          since: "0.4.0"
+        ),
+
         CheckRules::RULE_SUPPRESSION_UNKNOWN_RULE => Entry.new(
           id: CheckRules::RULE_SUPPRESSION_UNKNOWN_RULE,
           summary: "A `# rigor:disable[-file]` comment names a rule that does not exist.",
@@ -893,6 +980,48 @@ module Rigor
           since: "0.3.4"
         ),
 
+        CheckRules::RULE_CONTRADICTING_SIGNATURE => Entry.new(
+          id: CheckRules::RULE_CONTRADICTING_SIGNATURE,
+          summary: "Two declarations of one method provably contradict: no value or call satisfies both.",
+          fires_when: [
+            "A method is declared both in the project's `sig/` and by an inline `# @rbs` / `#:` " \
+            "annotation, and the return or a parameter every call must pass holds two proven-disjoint " \
+            "types — distinct literals, a literal outside such a class, or two classes written absolutely " \
+            "whose RBS comes from Ruby core or the stdlib, neither an RBS ancestor of the other " \
+            "(`::String` against `::Integer`) — or the two keyword-free declarations accept " \
+            "positional counts that cannot meet, or one requires a keyword the other cannot take in any " \
+            "form. Several overloads are paired by correspondence, never by order. Positioned at the " \
+            "`.rbs` member; Rigor reads that declaration.",
+            "A member-level `%a{rigor:v1:return: …}` or `%a{rigor:v1:param: …}` refinement is proven " \
+            "disjoint from the type its own member declares, in every overload it applies to " \
+            "(`rigor:v1:return: positive-int` on `-> String`)."
+          ],
+          does_not_fire_when: [
+            "One declaration refines the other (`String` against `non-empty-string`, `Symbol` against " \
+            "`:asc | :desc`, `bool` against `TrueClass`): the two merge to the more precise one, silently.",
+            "Either side is `untyped`, `void` or `top` in that position — consistent with everything.",
+            "Rigor cannot prove the two contradict: a module or interface on either side, a class the " \
+            "project declares (in `sig/`, inline or only in Ruby), a gem's class, any relative class name, " \
+            "two element types of one generic class, a type alias, `self`, a type variable, a proc, an " \
+            "optional or rest position, any block position, overloads that do not pair one to one, or " \
+            "differently shaped parameter lists that still overlap. The " \
+            "inline signature is then dropped and reported as `source-rbs-annotation-not-honoured` (info).",
+            "A refinement is written on one overload rather than on the member: call sites do not honour it.",
+            "Two `.rbs` files declare the same method (that fails the class's definition build, " \
+            "`rbs.coverage.definition-build-failed`), or a project `.rbs` collides with bundled RBS " \
+            "(the file is quarantined, `rbs.coverage.quarantined-signature`)."
+          ],
+          suppression: "`disable: [\"rbs.contradicting-signature\"]` in `.rigor.yml`, or a baseline entry. A " \
+                       "`# rigor:disable` comment does not reach a row positioned in a `.rbs` file. The real " \
+                       "fix is to regenerate the stale signature or correct the annotation.",
+          severity_authored: :error,
+          severity_by_profile: { lenient: :error, balanced: :error, strict: :error },
+          # Both sides are authored declarations, and a firing needs a proof that no value or call satisfies
+          # both — the ADR-35 both-sides-authored construction, with every doubt routed to the `:info` row.
+          evidence_tier: :high,
+          since: "0.4.0"
+        ),
+
         CheckRules::RULE_SUPPRESSION_UNKNOWN_MARKER => Entry.new(
           id: CheckRules::RULE_SUPPRESSION_UNKNOWN_MARKER,
           summary: "A comment uses a suppression marker Rigor does not recognise " \
@@ -922,6 +1051,7 @@ module Rigor
           since: "0.3.0"
         )
       }.freeze
+      Ractor.make_shareable(ENTRIES)
 
       module_function
 

data/lib/rigor/analysis/run_cache_key.rb

@@ -80,17 +80,25 @@ module Rigor
       # collecting project's path-set churn is the same churn, and over-evicting costs one recompute.
       EFFECTS_GENERATION_CAP = GENERATION_CAP
 
-      # @param rbs_config_entries [Array<Cache::Descriptor::ConfigEntry>] the RBS-derived config slots
+      # @param rbs_config_entries — the RBS-derived config slots
       #   (`rbs.libraries` [+ `rbs.virtual_rbs`]). nil on any failure so a malformed key disables the cache.
-      def descriptor(configuration:, files:, explain:, rbs_config_entries:)
+      # @param template_units_digest — #392 — the run's template-unit identity
+      #   ({Analysis::TemplateUnits#digest}: every unit's source bytes + transform id + synthesis version).
+      #   nil for a project whose plugins declare no `template_globs:`, which is every project today, and a
+      #   nil contributes NO slot — so no existing key moves. A project that DOES have units produces a key
+      #   the ADR-87 boot-slim probe (which loads no plugin and so passes nil) cannot reconstruct: the probe
+      #   simply misses and the full path takes over, the same forgone-fast-lane trade the `rbs.virtual_rbs`
+      #   slot already makes, and never a wrong hit.
+      def descriptor(configuration:, files:, explain:, rbs_config_entries:, template_units_digest: nil)
         Cache::Descriptor.new(
           gems: [Cache::RbsDescriptor.rbs_gem_entry],
-          configs: rbs_config_entries + engine_source_entries + lockfile_entries(configuration) + [
-            config_entry("configuration", Marshal.dump(configuration.to_h)),
-            config_entry("engine",
-                         "#{Rigor::VERSION}:#{Cache::Descriptor::SCHEMA_VERSION}:#{explain}"),
-            config_entry("paths", files.sort.join("\n"))
-          ]
+          configs: rbs_config_entries + engine_source_entries + lockfile_entries(configuration) +
+                   template_unit_entries(template_units_digest) + [
+                     config_entry("configuration", Marshal.dump(configuration.to_h)),
+                     config_entry("engine",
+                                  "#{Rigor::VERSION}:#{Cache::Descriptor::SCHEMA_VERSION}:#{explain}"),
+                     config_entry("paths", files.sort.join("\n"))
+                   ]
         )
       rescue StandardError
         nil
@@ -104,11 +112,12 @@ module Rigor
       #
       # {Cache::EngineSource::Unavailable} is left to propagate into `descriptor`'s rescue, which disables
       # the cache for the run: an engine we cannot identify must not be keyed by its version alone.
-      def engine_source_entries
-        identity = Cache::EngineSource.process_identity
-        return [] if identity.nil?
+      def template_unit_entries(digest)
+        digest.nil? ? [] : [config_entry("template-units", digest)]
+      end
 
-        [config_entry("engine-source", identity)]
+      def engine_source_entries
+        Cache::EngineSource.key_config_entries
       end
 
       # Issue #564 — the two dependency lockfiles, BY CONTENT. Both are inputs to the run's diagnostics and

data/lib/rigor/analysis/run_cache_probe.rb

@@ -51,17 +51,15 @@ module Rigor
     #   serves it instead. The decline is measured against the declarations alone, never against what they
     #   would judge to, so it costs one glob and never a wrong answer.
     class RunCacheProbe
-      # @param configuration [Rigor::Configuration]
-      # @param cache_root [String]
-      # @param explain [Boolean] the `--explain` flag (folded into the key, as the runner does).
+      # @param explain — the `--explain` flag (folded into the key, as the runner does).
       def initialize(configuration:, cache_root:, explain:)
         @configuration = configuration
         @cache_root = cache_root
         @explain = explain
       end
 
-      # @param paths [Array<String>] the analysis roots (`@argv` or `configuration.paths`).
-      # @return [Analysis::Result, nil] the cached run result with the severity profile applied and no stats
+      # @param paths — the analysis roots (`@argv` or `configuration.paths`).
+      # @return the cached run result with the severity profile applied and no stats
       #   (matching a cache-served `Runner#run`), or nil to DECLINE — a miss / stale / unavailable cache — so
       #   the caller loads the engine and runs the full path. Any failure declines rather than raising: the
       #   probe must never turn a servable run into a crash.

data/lib/rigor/analysis/runner/buffer_pool_dispatcher.rb

@@ -66,7 +66,7 @@ module Rigor
         # via `RIGOR_LSP_POOL_MIN_BATCH` (mirrors `RIGOR_RACTOR_WORKERS`'s override shape).
         DEFAULT_MIN_BATCH_SIZE = 16
 
-        # @return [Integer] `RIGOR_LSP_POOL_MIN_BATCH` when set to a non-empty value, else
+        # @return `RIGOR_LSP_POOL_MIN_BATCH` when set to a non-empty value, else
         #   {DEFAULT_MIN_BATCH_SIZE}.
         def self.resolve_min_batch_size
           env_value = ENV.fetch("RIGOR_LSP_POOL_MIN_BATCH", nil)
@@ -75,19 +75,17 @@ module Rigor
           Integer(env_value)
         end
 
-        # @param configuration [Rigor::Configuration]
-        # @param cache_store [Rigor::Cache::Store, nil]
-        # @param environment [Rigor::Environment] the warm, shared per-session Environment
+        # @param environment — the warm, shared per-session Environment
         #   (`ProjectContext#environment`) every job's Runner reuses instead of rebuilding.
-        # @param prebuilt [Rigor::Analysis::ProjectScan] the warm, shared pre-pass snapshot
+        # @param prebuilt — the warm, shared pre-pass snapshot
         #   (`ProjectContext#project_scan`) every job's Runner adopts instead of re-scanning.
-        # @param workers [Integer] pool size. `#analyze` degrades to sequential in-process execution — one
+        # @param workers — pool size. `#analyze` degrades to sequential in-process execution — one
         #   job at a time, no `fork` — when fewer than 2 bindings are submitted, fewer than `min_batch_size`
         #   bindings are submitted, `workers` is not positive, `fork` is unavailable on this platform, or
         #   `cache_store` is nil. The middle two are the fork-pool-is-not-worth-it-yet gate documented on
         #   {DEFAULT_MIN_BATCH_SIZE}; the last two mirror
         #   {PoolCoordinator#analyze_files_in_pool}'s own fork-pool preconditions.
-        # @param min_batch_size [Integer] see {DEFAULT_MIN_BATCH_SIZE}. Exposed as a constructor param
+        # @param min_batch_size — see {DEFAULT_MIN_BATCH_SIZE}. Exposed as a constructor param
         #   (rather than read from the env internally) purely for spec control; production callers get the
         #   resolved default.
         def initialize(configuration:, cache_store:, environment:, prebuilt:, workers:,
@@ -185,7 +183,7 @@ module Rigor
           degraded
         end
 
-        # @return [Hash, nil] the child's `{index => diagnostics}` payload, or nil when the child exited
+        # @return the child's `{index => diagnostics}` payload, or nil when the child exited
         #   abnormally or wrote no readable payload. `Marshal.load` is safe here: the blob was written by our
         #   own forked child to a temp file we created.
         def fork_worker_payload(status, out_path)

data/lib/rigor/analysis/runner/declaration_position.rb

@@ -20,8 +20,7 @@ module Rigor
 
         module_function
 
-        # @param finding [#location]
-        # @return [Array(String, Integer)] `[path, line]`
+        # @return `[path, line]`
         def of(finding)
           location = finding.location
           return [CONFIG_PATH, 1] if location.nil?