rigortype 0.4.4 → 0.4.6

data/docs/manual/10-mcp-server.md

@@ -66,7 +66,9 @@ rigor mcp [--transport=stdio] [--config=PATH]
   transport is queued for v2.
 - `--config=PATH` — session-level default config path. Individual tool
   calls may supply their own `config` argument, which takes precedence.
-  Without either, `Configuration.discover` walks `.rigor.yml` /
+  A path that names no file is an error, not a silent switch to the
+  defaults, for the session default and for a per-call `config` alike:
+  the call returns `isError: true`. Without either, `Configuration.discover` walks `.rigor.yml` /
   `.rigor.dist.yml` from the working directory.
 
 Exit codes: 0 (clean shutdown — stdin EOF), 64 (unknown
@@ -391,6 +393,13 @@ Generate RBS skeleton signatures inferred from Ruby source files.
 project's test roots: the configured `test_paths:`, or whichever of
 `spec/` and `test/` exist.
 
+Under `params: "observed"` the response also carries a top-level
+`observation` object, `{"paths": [...], "missing": [...]}`: the test
+roots that were read and the declared ones that do not exist or that
+the collector would not read (neither a directory nor a `.rb` file). Both
+empty means no test root was found, so every parameter stays `untyped`.
+The key is absent under the default `untyped` policy.
+
 **Returns:** JSON — the same as `rigor sig-gen --print --format json`.
 
 ```json
@@ -410,6 +419,12 @@ project's test roots: the configured `test_paths:`, or whichever of
 Classifications: `new-file`, `new-method`, `tighter-return`,
 `equivalent`, `skipped`.
 
+A `paths` entry that is neither a directory nor a `.rb` file is reported
+under a top-level `diagnostics` array, in the shape `rigor_check` uses
+(`"message": "no such file or directory"`). It is a warning beside
+paths that were read, and an error when none was. An empty `candidates`
+list with no `diagnostics` means nothing was found to generate.
+
 **Typical agent use:** call `rigor_sig_gen` to see which methods have
 precise enough returns to be worth writing into `sig/`, then generate
 and insert the RBS. The agent should NOT write signatures
@@ -430,7 +445,7 @@ Look up the description of one or all Rigor diagnostic rules.
 
 Accepted values: a canonical rule ID (`call.undefined-method`), a
 legacy alias (`undefined-method`), or a family prefix (`call`, `flow`,
-`assert`, `dump`, `def`).
+`def`, `assert`, `dump`, `global`, `suppression`, `static`, `effect`).
 
 **Returns:** JSON — an array of rule catalog entries.
 

data/docs/manual/12-caching.md

@@ -185,7 +185,14 @@ exactly which files an edit can affect. A continuous-integration
 gate, `rigor check --verify-incremental`, asserts this on every
 build: it runs the incremental analyzer and a full analysis and
 fails if they disagree on a single diagnostic, or list the same
-diagnostics in a different order.
+diagnostics in a different order. That gate re-analyses an
+unchanged tree, so it cannot see an edit that fails to re-check a
+file it affects. `--verify-incremental-edits=N` also edits `N`
+files one at a time, in memory and not on disk, and compares each
+warm recheck with a full analysis of the edited tree. Each file is
+edited twice: once emptied, and once reduced to its `class` /
+`module` declarations with every body dropped. It replays only
+those two removals, never an addition or any other edit.
 
 Rigor is also precise about *what* an edit changed. Re-checking a
 file that many others depend on — a base class, a widely-used

data/docs/manual/18-removing-dead-code.md

@@ -6,7 +6,9 @@ into a finite list of specific questions. It does not answer them.
 
 The command reference — every flag, every output section — is in
 [CLI reference](02-cli-reference.md#rigor-unused). This chapter is the
-workflow around it.
+workflow around it. For an AI coding agent, the bundled
+[`rigor-unused-adjudicate`](08-skills.md) skill walks through this
+adjudication workflow step by step.
 
 **Before you start** you need a working `rigor check` setup: a config
 file with `paths:`, and the plugins for your framework enabled. See
@@ -270,12 +272,21 @@ implicit, `self` or `self.class` inside a method (or a block in a class
 body, such as a lambda or `define_method`), the call may run on a
 subclass or on an includer, so a `Handler` declared in a descendant is
 kept reachable too. Descendants are the classes written `class D < Base`
-and the declarations whose body has a plain `include`, `prepend` or
-`extend` of the module; `K.include(Mix)`, `K.send(:include, Mix)`,
-`K.extend(Ext)` and `K = Class.new(Base)` are not followed yet. A call
-written directly in a class body is not widened. Inside
-`Other.instance_eval { }` (or `class_eval`, `module_eval` and their
-`_exec` forms) the receiver is `Other`. A name built into a
+or `K = Class.new(Base)`, and the classes that `include`, `prepend` or
+`extend` the module in their body or through a receiver Rigor can name:
+`K.include(Mix)` in an initializer, its `send`, `public_send` and
+`__send__` spellings, or `include Mix` inside `K.class_eval { }`. A call written directly in a
+class body is not widened. Inside `Other.instance_eval { }` (or
+`class_eval`, `module_eval` and their `_exec` forms) the receiver is
+`Other`, and a method the block defines (`def`, `define_method`,
+`define_singleton_method`) runs on `Other` or a descendant. When the
+receiver cannot be named at all, the name is kept wherever it is
+declared: an eval block on a local variable (`k.class_eval { }`), the
+module's own lookups when such a receiver includes it, or a class that
+includes a computed module (`K.include(mods.first)`). A class that gains
+a module through a receiver Rigor cannot name (`[Foo].each { |k|
+k.include(Consts) }`, an `include` in a `Class.new` block) is not
+followed for its own lookups of that module's constants. A name built into a
 local variable first (`name = "V#{version}"; const_get(name)`) is read
 the same way. A
 class name appearing as a string in a `.yml`, `.json` or template file

data/docs/manual/plugins/rigor-actionmailer.md

@@ -77,6 +77,36 @@ plugins:
   `--fail-on=warning` run — regenerate with `rigor baseline
   regenerate`.
 
+## Instance variable writes across actions
+
+The plugin tells the engine that a mailer runs one action per instance
+([ADR-125](../../adr/125-per-invocation-classes.md)). Its manifest lists
+`ActionMailer::Base` in `per_invocation_classes:`, and the callback macros
+(`before_action` and the rest) and `helper_method` in
+`per_invocation_non_action_macros:`, so a method those name is not an action.
+
+So [`def.ivar-write-mismatch`](../04-diagnostics.md#rule-def-ivar-write-mismatch)
+stays silent when `welcome` assigns `@items = [1, 2]` and `digest` assigns
+`@items = { a: 1 }`. It still reports two divergent writes in the same action,
+and a divergence that involves a private or protected helper, `initialize`, or a
+callback target or `helper_method` that a macro in the same file names.
+
+The callback macros include `before_deliver`, `after_deliver` and
+`around_deliver`, which run on the action's own instance.
+
+Two shapes stay silent because their macros are not listed: a public
+method named by `rescue_from X, with: :handler` or by `layout :method_name`
+counts as an action, as does one a lambda callback
+(`before_action -> { load_roles }`) reaches ([#2320](https://github.com/rigortype/rigor/issues/2320) tracks the fix).
+
+Visibility is read in source order, as Rails builds `action_methods` from the
+public instance methods. A method that ends up protected or private is not an
+action: it follows a bare `protected` or `private`, is named by `private :x` or
+`protected :x`, or is defined inline (`private def x`). `public :x` or
+`public def x` makes it one again. So it is no longer checked for a view
+template, and calling it (`UserMailer.helper`) reports `unknown-action` at
+error severity, as Rails raises `NoMethodError` for it.
+
 ## Plugin internals
 
 The mailer/concern discoverer, the cached `:mailer_index` producer,

data/docs/manual/plugins/rigor-actionpack.md

@@ -41,6 +41,36 @@ no-op rather than erroring.
 | `plugin.actionpack.permit-call` | info | a `params.require(:m).permit(:key, …)` chain resolved to a known model; keys matched against its columns |
 | `plugin.actionpack.unknown-permit-key` | error | a literal `permit(:key)` is a near-miss (edit distance ≤ 2) of a real column but not one — a likely typo (with a did-you-mean). A key nothing like any column (a legitimate virtual attribute) does not fire |
 
+The plugin also tells the engine that a controller runs one action
+per instance ([ADR-125](../../adr/125-per-invocation-classes.md)).
+Its manifest lists `ActionController::Base` and
+`ActionController::API` in `per_invocation_classes:`. It also lists
+the callback macros (`before_action` and the rest) and
+`helper_method` in `per_invocation_non_action_macros:`, so a method
+those name is not an action.
+
+So `def.ivar-write-mismatch` stays silent when `index` assigns
+`@roles = Role.sorted.to_a` and `permissions` assigns
+`@roles = Role.sorted`. It still reports a divergence that involves
+a private or protected helper, `initialize`, or two writes in the
+same action. It also still reports one that involves a callback
+target or `helper_method`, when the macro naming it sits in the same
+file as the method. Actions defined in a concern module and
+`ActionController::Metal` controllers keep reporting too.
+
+Two shapes stay silent because their macros are not listed: a public
+method named by `rescue_from X, with: :handler` or by `layout :method_name`
+counts as an action, as does one a lambda callback
+(`before_action -> { load_roles }`) reaches ([#2320](https://github.com/rigortype/rigor/issues/2320) tracks the fix).
+
+These shapes stay silent:
+
+- a public method named only by a macro in another file or a
+  concern, such as `ApplicationController`;
+- a public method a lambda callback reaches
+  (`before_action -> { load_roles }`);
+- an action that calls another action.
+
 Filter and render resolution honours nested-module controller
 qualification (`module Admin; class WidgetsController` resolves
 views under `admin/widgets/…`) and silences gem-shipped parent

data/docs/manual/plugins/rigor-devise.md

@@ -48,6 +48,21 @@ whatever class includes the concern.
 
 ## Limitations
 
+- **Needs RBS for the Devise modules.** The methods come from the
+  strategy modules' signatures (`Devise::Models::DatabaseAuthenticatable`
+  and the rest), which Rigor does not bundle and the `devise` gem does
+  not ship. Supply them through `signature_paths:` (or a
+  `rbs collection`); a strategy module with no signature contributes
+  nothing, and the model's `valid_password?` and friends stay as they
+  were. `plugins/rigor-devise/demo/sig/devise.rbs` is a minimal
+  example.
+- **Your own definitions win.** A method the model defines itself
+  (`def`, `alias_method`, `attr_*`, `define_method`, `delegate`), or
+  that a module of your project it includes or prepends defines, is
+  left to that definition rather than typed from the Devise module.
+  This holds even for a module included before the `devise` call,
+  which Devise's module would override at runtime. Only the module's
+  own public methods are contributed.
 - **Instance methods only.** Per-module `ClassMethods` (e.g.
   `User.reset_password_by_token`) are not yet synthesised.
 - **Controller helpers deferred.** `current_user` /

data/docs/manual/plugins/rigor-rspec.md

@@ -5,7 +5,9 @@ Validates RSpec `let` / `subject` declarations within each
 checks it ships have the lowest false-positive risk of the
 proposed RSpec surface, run in pure syntactic-walk mode, and
 catch real bugs that `rspec` / `rubocop-rspec` don't always
-surface clearly. No RSpec runtime dependency.
+surface clearly. It also narrows a local through `expect(x).to`
+matchers, described under [Matcher narrowing](#matcher-narrowing).
+No RSpec runtime dependency.
 
 It ships bundled in `rigortype`. Activate it under `plugins:`:
 
@@ -50,6 +52,105 @@ The walker recognises `RSpec.describe … do` (root), nested
 `describe` / `context … do`, `let(:name)` / `let!(:name)`, and
 `subject(:name)` / bare `subject` (the implicit `:subject`).
 
+## Matcher narrowing
+
+`expect(x).to MATCHER` narrows the local `x` for the rest of the
+example body, so downstream calls resolve against the matched type.
+Only a plain local is a target.
+
+```ruby
+RSpec.describe "Counter" do
+  it "narrows through the matcher" do
+    count = rand(10) if rand(2).zero?  # count is Integer?
+    expect(count).to eq(42)            # count is 42 from here on
+    count + 1                          # no possible-nil-receiver warning
+  end
+end
+```
+
+| Matcher | Effect on `x` |
+| --- | --- |
+| `eq(literal)` / `eql(literal)` | meet with `Constant<literal>` (see below) |
+| `be_a(T)` / `be_kind_of(T)` / `be_instance_of(T)` / `be_an_instance_of(T)` | meet with `T` |
+| `be_nil` | narrow to `Constant<nil>` |
+| `match(/regex/)` | keep the `String` and `Symbol` members, read an `Object`, `BasicObject` or module member as `String \| Symbol`, and remove `nil`, `true`, `false` and numeric members (unless the project defines `match`, `to_str` or `==` on them); unchanged when a member may be anything else |
+| `not_to be_nil` / `to_not be_nil` | narrow away from `nil` |
+| `not_to be_a(T)` / `not_to be_kind_of(T)` / `not_to be_instance_of(T)` / `not_to be_an_instance_of(T)` | narrow away from `T` |
+| `not_to eq(literal)` / `not_to eql(literal)` (and `to_not`) | unchanged (see below) |
+| `not_to match(/regex/)` (and `to_not`) | unchanged: a `String` that does not match passes |
+
+Other matchers emit nothing. `be_truthy` is not narrowed, nor is
+`expect { ... }.to raise_error(...)` (the block form), nor an
+`expect(foo.bar)` whose argument is not a local.
+
+### Equality is a meet, not a replacement
+
+`eq(literal)` passes when `x == literal`, and `eql(literal)` when
+`x.eql?(literal)`. The local is the receiver, so `x`'s own operator
+decides, and that operator can hold across classes: `1 == 1.0`, and a
+class with its own `==` (a `ModInt` that compares `to_i`) passes
+`expect(m).to eq(9)`. The matcher therefore never replaces `x`'s
+type. It narrows each member of `x`'s type on its own.
+
+The core equality classes are the nine in `EQUALITY_CORE_CLASSES`
+(`plugins/rigor-rspec/lib/rigor/plugin/rspec/matcher_analyzer.rb`):
+`Integer`, `Float`, `Rational`, `Complex`, `String`, `Symbol`,
+`NilClass`, `TrueClass`, and `FalseClass`. The first four are the
+numeric classes.
+
+- a member of the literal's own class narrows to the literal,
+  refinements of that class included. After `x = rand(10)`,
+  `expect(x).to eq(9)` gives `9`; `Integer?` with `eq(9)` gives `9`,
+  because the `nil` member cannot equal `9`. A refinement such as
+  `decimal-int-string?` (from `y = x && x.to_s` with `x` an
+  `Integer?`) gives `"3"` under `eq("3")`. A `Constant` member is kept
+  when it equals the literal and dropped otherwise;
+- a `Float` member meets `0.0` and is kept, since `-0.0` also equals
+  it;
+- a numeric member of another class (`Integer`, `Float`, `Rational`,
+  `Complex`) is kept under `eq`: `Integer | Float` with `eq(1)` gives
+  `1 | Float`;
+- any other member of a core equality class is dropped:
+  `String | Integer` with `eq(9)` gives `9`;
+- `eql(literal)` takes the same path, except that a numeric member of
+  another class is dropped, because `eql?` compares classes:
+  `Integer | Float` with `eql(1)` gives `1`.
+
+### A member, or the whole local, keeps its type in these cases
+
+A member outside the core equality classes makes the whole fact
+unavailable, so the local keeps its type, not just that member:
+
+- a member is `Dynamic`, or of a class outside `EQUALITY_CORE_CLASSES`,
+  such as a user class (`ModInt`), `Numeric`, or a generic `Array` or
+  `Hash`. Under `eq(9)` the whole local stays unchanged, so `9 | [1]`
+  and `9 | { a: 1 }` do not narrow;
+- the project defines the operator (`==` for `eq`, `eql?` for `eql`)
+  on the literal's class, in any analysed file. A `def` or a
+  `define_method` both count. A core `==` can call back into the
+  literal's own `==` (`Integer#==` for a non-numeric argument,
+  `String#==` for one that responds to `to_str`), so the plugin does
+  not narrow there even when a kept member would survive;
+- the project reopens a core ancestor of the member's class and
+  defines the operator there, such as `class Numeric; def eql?` or
+  `class Object; def ==`. Under `eql(9)` an `Integer` stays
+  `Integer`; under `eq(9)` the `nil` member of `Integer?` stays `nil`
+  while the `Integer` member narrows (`9?`);
+- the literal is `nil`, `true`, or a Symbol, and a member is a user
+  class or `Dynamic`: the local's own `==` can match these literals
+  too, so the local keeps its type as it does for `9`;
+- the local is unbound, no scope is available, or no member survives
+  the match (`nil` with `eq(9)`).
+
+A reopening that defines only other methods, such as
+`class String; def shout`, does not count: `String?` with
+`eq("a")` still narrows to `"a"`. A `class Symbol; def ==` in the
+project keeps the `Symbol` member and narrows the rest:
+`Symbol | Integer | nil` with `eq(9)` gives `9 | Symbol`.
+
+`not_to eq(literal)`, `to_not eq(literal)`, and their `eql` forms do
+not narrow: `x` keeps the type it had before the matcher.
+
 ## Configuration
 
 No configuration knobs. The plugin walks every file on the

data/lib/rigor/analysis/buffer_binding.rb

@@ -24,6 +24,20 @@ module Rigor
       def display_path(path)
         path == physical_path ? logical_path : path
       end
+
+      # The file's identity for comparing two spellings of one path: its real path, resolved through its directory
+      # when the file is absent from disk (a new buffer's file), so a symlinked root or parent spells it as it spells
+      # an existing file. Two accepted limits: a missing name is compared as written, so a name that differs only in
+      # case is not matched; and a `..` in a missing path is resolved textually, not through the filesystem.
+      def self.real_path(path)
+        File.realpath(path)
+      rescue SystemCallError
+        absolute = File.absolute_path(path)
+        parent = File.dirname(absolute)
+        return absolute if parent == absolute
+
+        File.join(real_path(parent), File.basename(absolute))
+      end
     end
   end
 end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../../inference/narrowing"
+require_relative "../../environment/member_consistency"
+
+module Rigor
+  module Analysis
+    module CheckRules
+      # Issue #1485 — whether a `case` clause the engine reads as exhausted by the earlier clauses (`:prior_exhaustion`
+      # in {UnreachableClauseCollector}) is dead whatever the subject holds. The engine's `Bot` says only that the
+      # earlier clauses covered every member of the subject's type, and a type Rigor inferred or read from a signature
+      # may be narrower than what the program holds: `STDOUT` is typed `IO`, a test passes a `StringIO`, which is not an
+      # `IO`, and `case io when IO … when StringIO` runs the second arm.
+      #
+      # So the verdict stands when the subject entering the `case` is made only of carriers that record what the file
+      # literally shows (`x = 1; case x when Integer … when String`), or when every class the clause names is at or
+      # below a class an earlier clause names (`when IO … when File`, `when Enumerable … when Array`, a repeated
+      # `when IO`): any object the clause could match then matches the earlier clause first. The ancestry is RBS's, or
+      # the project's own superclass and mixin edges, never past a class whose RBS ancestry Ruby contradicts
+      # (`Tempfile`, `< File` in RBS and `< Delegator` in Ruby). A clause that is not a class test (`in [a]`) names no
+      # class, so on a non-literal subject it is never proven.
+      #
+      # The proof assumes `when Base` matches every instance of a class below `Base`, as `Module#===` does. A class that
+      # defines its own `self.===` could break that; no such case has been observed.
+      class ClauseCoverage
+        # The carriers issue #1429 counts as literal, plus the value-pinned `nil`, `true` and `false`, whose `Nominal`
+        # is the single value itself.
+        LITERAL_CARRIERS = [Type::Constant, Type::Tuple, Type::HashShape, Type::Singleton].freeze
+        VALUE_PINNED_CLASSES = %w[NilClass TrueClass FalseClass].freeze
+
+        UNRELIABLE_ANCESTRY = Environment::MemberConsistency::RbsProof::UNRELIABLE_ANCESTRY
+
+        # @param scope — the `case` node's scope, which resolves the clauses' class constants.
+        # @param subject_type — the subject's type entering the `case`.
+        def initialize(scope, subject_type)
+          @scope = scope
+          @literal_subject = literal?(subject_type)
+          @earlier = []
+        end
+
+        # Adds the classes `clause` matches by class alone to those a later clause may be covered by: each class
+        # condition of a `when` (`when IO, nil` still matches every `IO` first), and the bare class pattern of an `in`.
+        def record(clause)
+          return if @scope.nil?
+
+          parts = clause.is_a?(Prism::WhenNode) ? clause.conditions : (pattern_alternatives(clause.pattern) || [])
+          @earlier.concat(parts.filter_map { |part| class_name(part) })
+        end
+
+        # True when the `:prior_exhaustion` verdict on `clause` may stand.
+        def proven?(clause)
+          return true if @literal_subject
+          return false if @scope.nil?
+
+          names = clause_class_names(clause)
+          return false if names.nil?
+
+          names.all? do |name|
+            ancestors = ancestor_names(name)
+            !ancestors.nil? && @earlier.any? { |earlier| ancestors.any? { |ancestor| covered_by?(ancestor, earlier) } }
+          end
+        end
+
+        private
+
+        def literal?(type)
+          members = type.is_a?(Type::Union) ? type.members : [type]
+          members.all? do |member|
+            LITERAL_CARRIERS.any? { |carrier| member.is_a?(carrier) } ||
+              (member.is_a?(Type::Nominal) && VALUE_PINNED_CLASSES.include?(member.class_name))
+          end
+        end
+
+        # The class names `clause` matches by class alone, or nil when any part of it is something else: every
+        # condition of a `when`, and the bare class pattern of an `in` (`in C`, `in C => x`, `in A | B`).
+        def clause_class_names(clause)
+          parts = clause.is_a?(Prism::WhenNode) ? clause.conditions : pattern_alternatives(clause.pattern)
+          return nil if parts.nil? || parts.empty?
+
+          names = parts.map { |part| class_name(part) }
+          names.include?(nil) ? nil : names
+        end
+
+        def class_name(node)
+          return nil unless node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
+
+          Inference::Narrowing.lexical_class_name(node, @scope)
+        end
+
+        def pattern_alternatives(pattern)
+          case pattern
+          when Prism::CapturePatternNode then pattern_alternatives(pattern.value)
+          when Prism::AlternationPatternNode
+            left = pattern_alternatives(pattern.left)
+            right = pattern_alternatives(pattern.right)
+            left && right && (left + right)
+          when Prism::ConstantReadNode, Prism::ConstantPathNode then [pattern]
+          end
+        end
+
+        # `name` and the ancestors the project gives it: the project classes and modules on its chain, and the first
+        # candidate the environment knows of each ancestor the project does not declare (`< StandardError`,
+        # `include Enumerable`). Nil when the chain was cut, so no coverage rests on part of it.
+        def ancestor_names(name)
+          return [name] unless @scope.known_user_class?(name)
+
+          external = @scope.external_ancestor_name_candidates(name).map do |candidates|
+            candidates.find { |candidate| Reflection.class_known?(candidate, scope: @scope) }
+          end
+          chain = Scope::ResolutionChain.for(@scope, name, :instance, :methods)
+          return nil if chain.truncated?
+
+          ([name] + chain.entries.reject(&:external?).map(&:name) + external.compact).uniq
+        end
+
+        # True when every instance of `name` is an instance of `earlier` by the environment's class ordering, past no
+        # class whose RBS ancestry Ruby contradicts.
+        def covered_by?(name, earlier)
+          environment = @scope.environment
+          case environment.class_ordering(name, earlier)
+          when :equal then true
+          when :subclass
+            UNRELIABLE_ANCESTRY.none? do |unreliable|
+              unreliable != earlier && %i[equal subclass].include?(environment.class_ordering(name, unreliable))
+            end
+          else false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -21,6 +21,14 @@ module Rigor
       # - the direct receiver / subject: `param.foo`, `case param`
       # - an indexed element: `param[i] - x` (the `-` receiver is the `[]` call whose root is `param`)
       # - any method chain: `param.foo.bar`, `param.foo(arg).baz`, `param.key?(:x)`
+      # - an array or hash literal holding the parameter (issue #2189): `[param].first.upcase`,
+      #   `{a: param}[:a].upcase`. The engine reads such an element back precisely, so the read is the
+      #   parameter's lower bound again; any other call on the literal declines too, the FP-safe direction.
+      # - an instance variable the same method wrote from such a value (issue #2189): `@x = param; @x.upcase`.
+      #   This one IS a scope mark — {Inference::StatementEvaluator#eval_ivar_write} stamps `:inferred_param`
+      #   under the ivar's `@`-prefixed name, which no local can spell — because the write and the read are
+      #   separate statements. The mark is method-local: the class-ivar census that seeds a sibling method's
+      #   ivars types the write's RHS without the inference seed, so a cross-method read is not a lower bound.
       #
       # Every value derived from an inferred parameter by dispatch is itself a lower bound, so firing against it
       # is an FP by the same construction. No-op on a normal `check` run — `Scope#inferred_param?` is false
@@ -36,17 +44,30 @@ module Rigor
           return false if node.nil? || depth > MAX_DEPTH
 
           case node
-          when Prism::LocalVariableReadNode then scope.inferred_param?(node.name)
+          when Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode then scope.inferred_param?(node.name)
           when Prism::CallNode then rooted?(node.receiver, scope, depth + 1)
-          # Value-combining forms: the produced value is a union of the operands, so it is a lower bound when
-          # ANY operand is inferred-parameter-rooted (`cps[i] - x rescue -1`, `a && param.foo`, `param || b`).
-          # Declining on the whole expression is FP-safe by the same lower-bound argument.
+          when Prism::ArrayNode, Prism::HashNode, Prism::KeywordHashNode, Prism::AssocNode
+            literal_rooted?(node, scope, depth + 1)
+          else combining_rooted?(node, scope, depth + 1)
+          end
+        end
+
+        # An array or hash literal is rooted when any element is: the engine reads the element back precisely.
+        def literal_rooted?(node, scope, depth)
+          parts = node.is_a?(Prism::AssocNode) ? [node.key, node.value] : node.elements
+          parts.any? { |part| rooted?(part, scope, depth) }
+        end
+
+        # Value-combining forms: the produced value is a union of the operands, so it is a lower bound when ANY
+        # operand is inferred-parameter-rooted (`cps[i] - x rescue -1`, `a && param.foo`, `param || b`). Declining
+        # on the whole expression is FP-safe by the same lower-bound argument.
+        def combining_rooted?(node, scope, depth)
+          case node
           when Prism::RescueModifierNode
-            rooted?(node.expression, scope, depth + 1) || rooted?(node.rescue_expression, scope, depth + 1)
-          when Prism::AndNode, Prism::OrNode
-            rooted?(node.left, scope, depth + 1) || rooted?(node.right, scope, depth + 1)
-          when Prism::ParenthesesNode then rooted?(last_statement(node.body), scope, depth + 1)
-          when Prism::StatementsNode then rooted?(node.body.last, scope, depth + 1)
+            rooted?(node.expression, scope, depth) || rooted?(node.rescue_expression, scope, depth)
+          when Prism::AndNode, Prism::OrNode then rooted?(node.left, scope, depth) || rooted?(node.right, scope, depth)
+          when Prism::ParenthesesNode then rooted?(last_statement(node.body), scope, depth)
+          when Prism::StatementsNode then rooted?(node.body.last, scope, depth)
           else false
           end
         end