rigortype 0.4.3 → 0.4.5

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

@@ -33,6 +33,7 @@ There is no conflict in running both simultaneously.
 | `rigor_check` | `rigor check --format json` | JSON diagnostic report |
 | `rigor_type_of` | `rigor type-of --format json` | JSON type at `FILE:LINE:COL` |
 | `rigor_triage` | `rigor triage --format json` | JSON distribution + class/method selectors + hotspots + hints |
+| `rigor_lens` | `rigor lens --format json` | JSON `lens/v0` declaration map (experimental) |
 | `rigor_annotate` | `rigor annotate --no-color` | Annotated Ruby source |
 | `rigor_sig_gen` | `rigor sig-gen --print --format json` | JSON RBS skeleton candidates |
 | `rigor_explain` | `rigor explain --format json` | JSON rule catalog entries |
@@ -320,6 +321,34 @@ by `count` for the highest-leverage class/method, or filter by
 
 ---
 
+### rigor_lens
+
+Map the classes, modules, methods and attributes the given files declare,
+with the type `rigor check` gives each one and where it came from. The
+document is the experimental `lens/v0` format
+([specification](../internal-spec/lens.md)); see
+[Inspecting inferred types](05-inspecting-types.md) for the command.
+
+**Input:**
+
+| Argument | Type | Required |
+|---|---|---|
+| `files` | `string[]` | yes |
+| `config` | `string` | no |
+
+**Returns:** JSON. Each file carries its `status`, `sites`, `omissions`
+and `diagnostics`; `members` holds the signatures.
+
+**Typical agent use:** learn what a file or class offers, and the
+contracts its methods already have, before editing it or writing a type.
+Pass every file in one call: each call runs one analysis, and the first
+call on a project costs a full `rigor check`. Paths, site keys and the cache are
+relative to the directory the server was started in, so start it from the
+project root; `--config` fixes which files belong to the project, not how
+paths are written.
+
+---
+
 ### rigor_annotate
 
 Return the given Ruby source file with each line's last-expression
@@ -362,6 +391,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
@@ -401,7 +437,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.
 
@@ -482,7 +518,7 @@ You should get a JSON response. If you get nothing or a shell error,
 `rigor` is not on your `PATH` — fix the install path first (see
 [Installing Rigor](01-installation.md)).
 
-**`rigor_check` / `rigor_triage` return an empty diagnostics array on a project that has errors.**
+**`rigor_check` / `rigor_triage` return an empty diagnostics array on a project that has errors, or `rigor_lens` reports every file `outside_project`.**
 
 The tool uses `Configuration.discover` from the working directory the
 MCP server was started in. If the client launches `rigor mcp` from a
@@ -517,8 +553,8 @@ warmed by a prior `rigor check` run reduces it significantly.
 
 ## Status and roadmap
 
-`rigor mcp` shipped in v0.1.10 with all seven tools and stdio
-transport. Queued follow-ups are demand-driven:
+`rigor mcp` shipped in v0.1.10 with seven tools and stdio
+transport; `rigor_lens` joined them in v0.4.4. Queued follow-ups are demand-driven:
 
 - **HTTP transport** (slice 2) — `--transport=http` for CI / remote
   agent use; a minimal Rack endpoint.

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
@@ -265,7 +267,26 @@ under them are. `const_get` looks the name up from its receiver, so
 and mixins and at the top level as well, unless the call passes `false`
 as its second argument. A literal `const_get("Handler")` is a reference
 looked up in the same order, so it names `Migration::Handler` when
-that exists rather than a top-level `Handler`. A name built into a
+that exists rather than a top-level `Handler`. When the receiver is
+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`
+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-rails-routes.md

@@ -127,8 +127,8 @@ routed. Helper-name recognition for all three is unaffected.
   metaprogramming the parser can't unfold (routes built in a loop
   over runtime data, helpers injected by an engine the parser
   doesn't model) may not register, which can surface a false
-  `unknown-helper`. Record those in a baseline, or
-  `# rigor:disable` the line.
+  `unknown-helper`. Record those in a baseline, or add
+  `# rigor:disable plugin.rails-routes.unknown-helper` to the line.
 - **The "routes file did not load" warning is run-scoped.** It is a
   fact about your configuration, not about any one source file, so
   it is reported once per run on `.rigor.yml` rather than on the

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,104 @@ 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/)` | narrow to `String` |
+| `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) |
+
+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/docs/manual/plugins/rigor-shoulda-matchers.md

@@ -48,7 +48,10 @@ expected kind: `belong_to` / `have_one` (singular), `have_many` /
 
 Suppress with the qualified rule, e.g.
 `# rigor:disable plugin.shoulda-matchers.unknown-column`, or silence
-the whole family with `# rigor:disable plugin.shoulda-matchers`.
+the whole family with `# rigor:disable plugin.shoulda-matchers`. The
+same spellings work project-wide in `.rigor.yml`'s `disable:`. The
+bare rule (`# rigor:disable unknown-column`) does not reach these
+diagnostics.
 
 ## No configuration
 

data/exe/rigor

@@ -6,8 +6,7 @@
 # (`RUBY_BOX=1`, not toggleable at runtime). When a project selects that
 # strategy (`RIGOR_PLUGIN_ISOLATION=ruby_box`, or the legacy `RIGOR_BOX`
 # alias) we re-exec the same command with the flag set before anything
-# else loads. The `RUBY_BOX` guard prevents an infinite re-exec, and the
-# inherited environment (RUBYOPT / BUNDLE_*) preserves the Bundler
+# else loads. The inherited environment (RUBYOPT / BUNDLE_*) preserves the Bundler
 # context across the exec. The `none` and `process` (default) strategies
 # need no flag, so this is a no-op for them — behaviour is unchanged
 # unless a project opts into `ruby_box`.
@@ -17,22 +16,18 @@
 # Rubies through 4.0.7 segfault on Ruby Bug #22260). When it cannot,
 # the request is dropped with a warning and the run proceeds under the
 # configured strategy (`process` by default) instead of crashing.
-rigor_isolation = ENV["RIGOR_PLUGIN_ISOLATION"].to_s
-rigor_wants_box = rigor_isolation == "ruby_box" || !ENV["RIGOR_BOX"].to_s.empty?
-if rigor_wants_box && ENV["RUBY_BOX"].to_s.empty?
+#
+# When `RUBY_BOX` is already set (by hand or by a wrapper), this process
+# booted inside the box before any Rigor code ran, so the same probe
+# runs here too, and a refused Ruby is re-exec'ed with `RUBY_BOX`
+# removed. The probe's verdict is cached per Ruby build, and the
+# re-exec is marked so the child neither probes nor re-execs again.
+# Nothing above `require "rigor/cli"` may define a Ractor-shareable
+# lambda: that is what crashes inside the box.
+if !ENV["RUBY_BOX"].to_s.empty? || ENV["RIGOR_PLUGIN_ISOLATION"].to_s == "ruby_box" ||
+   !ENV["RIGOR_BOX"].to_s.empty? || ENV.key?("RIGOR_BOX_PROBED")
   require_relative "../lib/rigor/plugin/box_probe"
-  if (rigor_box_unsupported = Rigor::Plugin::BoxProbe.unsupported_reason)
-    rigor_box_warning = "rigor: ruby_box plugin isolation is unavailable: #{rigor_box_unsupported}. " \
-                        "Falling back to the configured plugins_isolation strategy (default: process)."
-    # `$stderr.puts`, not `warn`: `-W0` silences `warn`, and this fallback must never be silent.
-    $stderr.puts rigor_box_warning # rubocop:disable Style/StderrPuts
-    ENV.delete("RIGOR_PLUGIN_ISOLATION") if rigor_isolation == "ruby_box"
-    ENV.delete("RIGOR_BOX")
-  else
-    ENV["RUBY_BOX"] = "1"
-    ENV["RIGOR_PLUGIN_ISOLATION"] = "ruby_box" if rigor_isolation.empty?
-    exec(RbConfig.ruby, __FILE__, *ARGV)
-  end
+  exec(RbConfig.ruby, __FILE__, *ARGV) if Rigor::Plugin::BoxProbe.needs_reexec?(ENV)
 end
 
 lib = File.expand_path("../lib", __dir__)

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/lexical_method_sites.rb

@@ -17,6 +17,13 @@ module Rigor
       # - **Singleton defs on locals.** `def o.m` defines `m` on the one object `o` holds. The local's type
       #   is not changed; `o.m` is simply not reported within the scope the `def` is written in (the
       #   enclosing `def`, `class` / `module` body, or file — a block shares its enclosing scope's locals).
+      #   Issue #1722 — the other spellings that give that one object methods make the local opaque for every
+      #   name in the same scope: `o.extend(M)`, `o.define_singleton_method(...)` (only the literal name it
+      #   defines, when it names one), any call on `o.singleton_class` (`class_eval { def m }`, `define_method`,
+      #   `include`), `class << o`, and an `o.instance_eval` / `o.instance_exec` that is given a String or whose
+      #   block writes a `def` or calls `extend` / `define_singleton_method`. Where in the scope the call sits,
+      #   and whether it runs, are not read: a call under an `if` may run. A local assigned `o.clone` shares
+      #   what `o` has (`clone` copies the singleton class, `dup` does not).
       #
       # Built lazily: the walk runs the first time a would-fire call asks, so a file with no such call pays
       # one small object and nothing else.
@@ -34,22 +41,45 @@ module Rigor
 
         def refinements = (@refinements ||= Inference::InEffectRefinements.new(@root))
 
-        # Does a `def <local>.<name>` for this call's local receiver and method name sit in the scope the call
-        # is in?
+        # Does a `def <local>.<name>` for this call's local receiver and method name — or a call that gives the
+        # local's object methods Rigor does not enumerate (issue #1722) — sit in the scope the call is in?
         def singleton_local_def?(call_node)
           receiver = call_node.receiver
           return false unless receiver.is_a?(Prism::LocalVariableReadNode)
 
           build
-          offset = call_node.location.start_offset
-          @singleton_defs.any? do |local, method_name, start, stop|
-            local == receiver.name && method_name == call_node.name && offset >= start && offset < stop &&
-              !nested_scope_holds?(offset, start, stop)
-          end
+          singleton_local_holds?(receiver.name, call_node.name, call_node.location.start_offset, CLONE_DEPTH)
         end
 
+        # The name an opening records when it may define any method on the local's object.
+        ANY_METHOD = Object.new.freeze
+        # How many `t = s.clone` links a lookup follows.
+        CLONE_DEPTH = 4
+        EVAL_CALLS = %i[instance_eval instance_exec].freeze
+        EVAL_BLOCK_CALLS = %i[extend define_singleton_method].freeze
+        private_constant :ANY_METHOD, :CLONE_DEPTH, :EVAL_CALLS, :EVAL_BLOCK_CALLS
+
         private
 
+        def singleton_local_holds?(local_name, method_name, offset, depth)
+          opened = in_scope?(@singleton_defs, offset) do |local, name|
+            local == local_name && (name.equal?(ANY_METHOD) || name == method_name)
+          end
+          return true if opened
+          return false if depth.zero?
+
+          @clones.any? do |target, source, start, stop|
+            target == local_name && offset >= start && offset < stop && !nested_scope_holds?(offset, start, stop) &&
+              singleton_local_holds?(source, method_name, offset, depth - 1)
+          end
+        end
+
+        def in_scope?(rows, offset)
+          rows.any? do |local, name, start, stop|
+            yield(local, name) && offset >= start && offset < stop && !nested_scope_holds?(offset, start, stop)
+          end
+        end
+
         # Is `offset` inside a local scope nested in the one `[start, stop)` spans? A `def` in the file's top level
         # does not see the top level's `o`.
         def nested_scope_holds?(offset, start, stop)
@@ -64,6 +94,7 @@ module Rigor
 
           @built = true
           @singleton_defs = []
+          @clones = []
           @scopes = []
           return if @root.nil?
 
@@ -78,11 +109,16 @@ module Rigor
           when Prism::ClassNode, Prism::ModuleNode
             return walk_children(node.body, scope_span(node))
           when Prism::SingletonClassNode
+            record_opened_local(node.expression, ANY_METHOD, locals)
             walk(node.expression, locals)
             return walk_children(node.body, scope_span(node))
           when Prism::DefNode
             record_singleton_def(node, locals)
             return walk_children(node.body, scope_span(node))
+          when Prism::CallNode
+            record_singleton_opening(node, locals)
+          when Prism::LocalVariableWriteNode
+            record_clone(node, locals)
           end
 
           walk_children(node, locals)
@@ -101,6 +137,74 @@ module Rigor
           @singleton_defs << [receiver.name, node.name, *locals]
         end
 
+        # Issue #1722 — a call that gives the object its receiver local holds singleton methods.
+        def record_singleton_opening(node, locals)
+          receiver = node.receiver
+          if singleton_class_of_local?(receiver)
+            record_opened_local(receiver.receiver, ANY_METHOD, locals)
+          elsif receiver.is_a?(Prism::LocalVariableReadNode)
+            name = opened_method_name(node)
+            record_opened_local(receiver, name, locals) if name
+          end
+        end
+
+        # `o.singleton_class`.
+        def singleton_class_of_local?(node)
+          node.is_a?(Prism::CallNode) && node.name == :singleton_class && node.arguments.nil? &&
+            node.receiver.is_a?(Prism::LocalVariableReadNode)
+        end
+
+        # The method name a call on a local defines on the local's object: the literal name given to
+        # `define_singleton_method`, {ANY_METHOD} where it may be any name, or nil when the call defines none.
+        def opened_method_name(node)
+          case node.name
+          when :extend then ANY_METHOD
+          when :define_singleton_method then literal_name(node.arguments&.arguments&.first) || ANY_METHOD
+          when *EVAL_CALLS then ANY_METHOD if eval_defines?(node)
+          end
+        end
+
+        def literal_name(node)
+          node.unescaped.to_sym if node.is_a?(Prism::SymbolNode) || node.is_a?(Prism::StringNode)
+        end
+
+        # An `instance_eval` given code as a String, or whose block writes a `def` or calls `extend` /
+        # `define_singleton_method` on its `self`.
+        def eval_defines?(node)
+          return true unless node.arguments.nil?
+
+          block = node.block
+          block.is_a?(Prism::BlockNode) && defines_on_self?(block.body)
+        end
+
+        def defines_on_self?(node)
+          return false if node.nil?
+          return true if node.is_a?(Prism::DefNode)
+          if node.is_a?(Prism::CallNode) && EVAL_BLOCK_CALLS.include?(node.name) &&
+             (node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode))
+            return true
+          end
+
+          found = false
+          node.rigor_each_child { |child| found ||= defines_on_self?(child) }
+          found
+        end
+
+        def record_opened_local(node, method_name, locals)
+          return unless node.is_a?(Prism::LocalVariableReadNode)
+
+          @singleton_defs << [node.name, method_name, *locals]
+        end
+
+        # `t = s.clone`: `clone` copies the singleton class, so `t` holds what `s` was given.
+        def record_clone(node, locals)
+          value = node.value
+          return unless value.is_a?(Prism::CallNode) && value.name == :clone
+          return unless value.receiver.is_a?(Prism::LocalVariableReadNode)
+
+          @clones << [node.name, value.receiver.name, *locals]
+        end
+
         # The span of a node that opens a local scope, recorded for {#nested_scope_holds?}.
         def scope_span(node)
           span = span_of(node)