rigortype 0.4.2 → 0.4.4

data/lib/rigor/environment/installed_gem_set.rb

@@ -35,11 +35,12 @@ module Rigor
         found.freeze
       end
 
-      # `<bundle>/ruby/X.Y.Z/gems/<name>-<version>/` — the same pure-filesystem layout
+      # `<bundle>/ruby/X.Y.Z/gems/<name>-<version>[-<platform>]/` — the same pure-filesystem layout
       # {MissingGemConstantIndex.bundle_gem_dirs} walks, preferred over the host's gems so a project that
       # vendored its bundle without committing the lockfile is read from its own tree. A platform-tagged
-      # directory (`ffi-1.17.4-aarch64-linux-gnu`) does not split into a name/version pair and is skipped:
-      # those gems ship native code, not the pure-Ruby constants this feeds.
+      # directory (`commonmarker-2.10.0-arm64-darwin`) is kept with its platform as a variant: those builds
+      # ship the same `lib/<name>.rb` and top-level namespace as the `ruby` one, and the index looks the
+      # directory up by that variant. A name installed more than once keeps every directory as a variant.
       def from_bundle_tree(bundle_path)
         return {} if bundle_path.nil?
 
@@ -47,10 +48,15 @@ module Rigor
         return {} unless base.directory?
 
         Dir.glob(base.join("ruby", "*", "gems", "*")).each_with_object({}) do |dir, acc|
-          name, version = split_name_version(File.basename(dir))
+          name, version, platform = split_install_dirname(File.basename(dir))
           next unless name
 
-          acc[name] ||= locked_gem(name, version)
+          prior = acc[name]
+          acc[name] = if prior
+                        prior.with(variants: [*prior.variants, [version, platform]])
+                      else
+                        locked_gem(name, version, platform)
+                      end
         end
       end
 
@@ -70,15 +76,36 @@ module Rigor
         {}
       end
 
-      def locked_gem(name, version)
-        LockfileResolver::LockedGem.new(name: name, version: version, platform: "ruby")
+      def locked_gem(name, version, platform = "ruby")
+        LockfileResolver::LockedGem.new(name: name, version: version, platform: platform)
       end
 
-      # Splits a gem install directory's basename. The version tail is anchored on a leading digit and must
-      # carry no further hyphen, which is what excludes the platform-tagged variants above.
-      def split_name_version(basename)
+      # Splits a gem install directory's basename into `[name, version, platform]`, or nil. The version
+      # always starts with a digit and carries no hyphen; a platform tail is accepted only when RubyGems
+      # recognises its OS (`arm64-darwin`, `x86_64-linux-gnu`, `java`), so `foo-2fa-1.0` stays the plain gem
+      # `foo-2fa`. The platform split is tried first, because a plain split of `foo-1.0-universal-darwin-23`
+      # would claim the name `foo-1.0-universal-darwin`; and from the rightmost version-shaped segment,
+      # because RubyGems also reads `1.0-x86_64-linux` as a linux platform, which would cut
+      # `foo-2fa-1.0-x86_64-linux` at `foo`.
+      def split_install_dirname(basename)
+        platform_split(basename) || plain_split(basename)
+      end
+
+      def platform_split(basename)
+        cuts = []
+        basename.scan(/-(\d[^-]*)(?=-.)/) { cuts << Regexp.last_match }
+        cuts.reverse_each do |match|
+          platform = match.post_match.delete_prefix("-")
+          # `current` makes `Gem::Platform.new` read the host's platform, which a non-main Ractor may not touch.
+          next if platform == "current"
+          return [match.pre_match, match[1], platform] unless Gem::Platform.new(platform).os == "unknown"
+        end
+        nil
+      end
+
+      def plain_split(basename)
         match = /\A(.+)-(\d[^-]*)\z/.match(basename)
-        match ? [match[1], match[2]] : nil
+        match ? [match[1], match[2], "ruby"] : nil
       end
     end
   end

data/lib/rigor/environment/lockfile_resolver.rb

@@ -30,13 +30,29 @@ module Rigor
       # dependency that moved from a `git:` source to a released version without a `bundle clean`, so its
       # git-installed directory is still sitting there under the OLD source's name). Defaults `false` so
       # existing callers that construct a `LockedGem` without an opinion stay conservative.
-      LockedGem = Data.define(:name, :version, :platform, :git_source) do
-        def initialize(name:, version:, platform:, git_source: false)
+      #
+      # `variants` is every `[version, platform]` pair the lockfile locks under this name, in Bundler's parsed
+      # order. A multi-platform lockfile (`bundle lock --add-platform`) lists one spec per platform — `ffi
+      # (1.17.4)`, `ffi (1.17.4-arm64-darwin)`, … — and Bundler installs whichever matches the host, so
+      # {BundleSigDiscovery} must admit all of them (#1844). `version` / `platform` name one representative
+      # variant for the readers that want a single version (coverage report, doctor): the `ruby` one when the
+      # lockfile has it, otherwise the last parsed. Defaults to the single `[version, platform]` pair, and the
+      # pair must be one of `variants`.
+      LockedGem = Data.define(:name, :version, :platform, :git_source, :variants) do
+        def initialize(name:, version:, platform:, git_source: false, variants: nil)
+          version = -version.to_s
+          platform = -platform.to_s
+          variants = (variants || [[version, platform]]).map { |v, p| [-v.to_s, -p.to_s].freeze }.uniq.freeze
+          unless variants.include?([version, platform])
+            raise ArgumentError, "LockedGem #{name}: [#{version}, #{platform}] is not one of its variants"
+          end
+
           super(
             name: -name.to_s,
-            version: -version.to_s,
-            platform: -platform.to_s,
-            git_source: git_source ? true : false
+            version: version,
+            platform: platform,
+            git_source: git_source ? true : false,
+            variants: variants
           )
         end
       end
@@ -162,10 +178,13 @@ module Rigor
           # `#source` is the `Bundler::Source::*` this spec resolved from — `Git` for a `GIT` lockfile
           # stanza, `Rubygems` for a `GEM` one, `Path`/`Gemspec` for `path:`. Only `Git` sources land under
           # {BundleSigDiscovery}'s `bundler/gems/` walk.
-          h[spec.name.to_s] = LockedGem.new(
+          # A multi-platform lockfile repeats the name once per platform; fold the repeats into `variants`
+          # instead of letting the last one overwrite the rest (#1844).
+          entry = LockedGem.new(
             name: spec.name, version: spec.version.to_s, platform: platform,
             git_source: spec.source.is_a?(Bundler::Source::Git)
           )
+          h[entry.name] = (prior = h[entry.name]) ? merge_variant(prior, entry) : entry
         end
         locked.freeze
       rescue ::Ractor::IsolationError => e
@@ -177,6 +196,18 @@ module Rigor
       end
       private_class_method :do_parse
 
+      # Folds a further platform variant of an already-parsed name into it. The representative keeps a `ruby`
+      # variant once seen; otherwise the last variant wins, as it did before variants were kept.
+      def self.merge_variant(prior, entry)
+        rep = prior.platform == "ruby" ? prior : entry
+        prior.with(
+          variants: [*prior.variants, [entry.version, entry.platform]],
+          version: rep.version, platform: rep.platform,
+          git_source: prior.git_source || entry.git_source
+        )
+      end
+      private_class_method :merge_variant
+
       # #1064 — Bundler's lockfile parser reads RubyGems module state a non-main Ractor may not touch, so the
       # parse raises `Ractor::IsolationError` there whatever the lockfile says. That is an engine constraint, not
       # a malformed lockfile, and the warning must not send the user to fix a file that is fine. The Ractor pool

data/lib/rigor/environment/missing_gem_constant_index.rb

@@ -37,8 +37,8 @@ module Rigor
     module MissingGemConstantIndex
       module_function
 
-      # @param gems — `[gem_name, version]` pairs (the `:missing` rows of
-      #   {RbsCoverageReport}).
+      # @param gems — `[gem_name, version, variants]` entries (the `:missing` rows of {RbsCoverageReport},
+      #   with the gem's `LockedGem#variants`); `variants` may be omitted or nil, meaning the `ruby` one.
       # @param bundle_path — the target's resolved bundler install root, or nil.
       # @param spec_resolver — `(name, version) -> String?` fallback dir resolver. Injectable for
       #   specs; the default is the RubyGems-metadata lookup (no code load).
@@ -49,8 +49,9 @@ module Rigor
         bundle_dirs = bundle_gem_dirs(bundle_path)
         git_dirs = git_gem_dirs(bundle_path)
         index = {}
-        gems.each do |gem_name, version|
-          dir = bundle_dirs["#{gem_name}-#{version}"] || git_dirs[gem_name] || spec_resolver.call(gem_name, version)
+        gems.each do |gem_name, version, variants|
+          dir = bundle_dir(bundle_dirs, gem_name, version, variants) ||
+                git_dirs[gem_name] || spec_resolver.call(gem_name, version)
           next unless dir
 
           entry_files(dir, gem_name).each do |file|
@@ -62,9 +63,8 @@ module Rigor
 
       # `{"<name>-<version>" => gem_dir}` for the target's bundle, or `{}` when no bundle is resolvable. The
       # glob covers the RUBYGEMS-sourced layout only, `<bundle>/ruby/X.Y.Z/gems/<name>-<version>/`; the
-      # git-sourced layout is {.git_gem_dirs}'s. Keyed on the dir basename so a platform-tagged variant
-      # (`ffi-1.17.4-aarch64-linux-gnu`) simply doesn't match a `<name>-<version>` lookup — those gems ship
-      # native code, not the pure-Ruby constants this indexes.
+      # git-sourced layout is {.git_gem_dirs}'s. Keyed on the dir basename, which {.bundle_dir} reconstructs
+      # per locked variant.
       def bundle_gem_dirs(bundle_path)
         return {} if bundle_path.nil?
 
@@ -76,6 +76,21 @@ module Rigor
         end
       end
 
+      # The installed directory of one of the gem's locked variants: `<name>-<version>` for the `ruby` one,
+      # `<name>-<version>-<platform>` for a platform-tagged one. Bundler installs only the variant matching
+      # the host, and a multi-platform lockfile's representative is usually the `ruby` one, so every variant
+      # is tried. A platform-tagged gem is not a native-only gem: the commonmarker, nokogiri and sqlite3 builds
+      # each ship `lib/<name>.rb` declaring the gem's top-level namespace, exactly as the `ruby` build does.
+      def bundle_dir(bundle_dirs, gem_name, version, variants)
+        [[version, "ruby"], *variants].each do |variant_version, platform|
+          basename = "#{gem_name}-#{variant_version}"
+          basename = "#{basename}-#{platform}" unless platform == "ruby"
+          dir = bundle_dirs[basename]
+          return dir if dir
+        end
+        nil
+      end
+
       # Issue #763 — `{gem_name => gem_dir}` for the target's GIT-sourced gems,
       # `<bundle>/ruby/X.Y.Z/bundler/gems/<repo>-<12-hex-revision>/`. Before this, a `git:`-sourced gem was
       # invisible to the index, so every constant reaching into it recorded the generic engine-gap cause

data/lib/rigor/environment/rbs_loader.rb

@@ -66,6 +66,15 @@ module Rigor
       QUARANTINE_WARN_LIMIT = 10
 
       class << self
+        # Issue #1902 — the fixed total order that picks ONE detail tuple for a class out of several: its two
+        # sides in {#report_definition_build_failure}, or a fresh and a replayed record in
+        # {Analysis::Runner::PoolCoordinator}. Content-only (the tuple carries no side), so both places choose
+        # the same tuple from the same candidates, whatever order those candidates arrived in.
+        def definition_build_detail_order(detail)
+          _, error_class, member, buffers, unresolved = detail
+          [error_class.to_s, member.to_s, Array(buffers).map(&:to_s), Array(unresolved).map(&:to_s)]
+        end
+
         def default
           @default ||= new.freeze
         end
@@ -2321,6 +2330,39 @@ module Rigor
         [].freeze
       end
 
+      # Issue #1752 — the lookup of `class_name`'s class object as RBS declares it, the singleton twin of
+      # {#ancestor_names_for}: `[:singleton, name]` for each singleton class on it (`C`'s, then each superclass's)
+      # and `[:instance, name]` for each module or class whose instance methods it reaches (the declared `extend`s,
+      # then `Class`, `Module`, `Object`, `Kernel` and `BasicObject` for a class, `Module` onwards for a module), in
+      # lookup order. A refinement of `Object` or `Module` answers a call on a class object through the second kind.
+      #
+      # Marked as an internal demand, as {#ancestor_names_for} is (issue #696). Memoised per name: the environment is
+      # immutable for the loader's lifetime.
+      #
+      # @return `::`-stripped pairs, or `[]` for an unknown class and on any RBS build error.
+      def singleton_ancestors_for(class_name)
+        key = class_name.to_s.delete_prefix("::")
+        memo = (@state[:singleton_ancestors] ||= {})
+        return memo[key] if memo.key?(key)
+
+        memo[key] = build_singleton_ancestors(key)
+      end
+
+      def build_singleton_ancestors(key)
+        during_internal_demand do
+          definition = singleton_definition(key)
+          next [].freeze if definition.nil?
+
+          definition.ancestors.ancestors.map do |ancestor|
+            kind = ancestor.is_a?(::RBS::Definition::Ancestor::Singleton) ? :singleton : :instance
+            [kind, ancestor.name.to_s.delete_prefix("::")].freeze
+          end.uniq.freeze
+        end
+      rescue ::RBS::BaseError, StandardError
+        [].freeze
+      end
+      private :build_singleton_ancestors
+
       # @return the class method on `class_name`. For example,
       #   `singleton_method(class_name: "Integer", method_name: :sqrt)` returns the definition for
       #   `Integer.sqrt`, while `singleton_method(class_name: "Foo", method_name: :new)` returns Class#new
@@ -2438,6 +2480,18 @@ module Rigor
         # fail-soft: a broken RBS environment yields no entries.
       end
 
+      # ADR-113 — the RBS declaration of the constant `name` (qualified) as `[type, buffer name]`, or nil when no
+      # signature declares it. `rigor lens` reports the declared type with the provenance the buffer names.
+      def constant_declaration(name)
+        rbs_name = parse_type_name(name)
+        entry = rbs_name && env&.constant_decls&.[](rbs_name)
+        return nil unless entry
+
+        [entry.decl.type.to_s, entry.decl.location&.buffer&.name.to_s]
+      rescue ::RBS::BaseError
+        nil
+      end
+
       # Slice A constant-value lookup. Returns the translated `Rigor::Type` for a non-class constant
       # declaration (`BUCKETS: Array[Symbol]`, `DEFAULT_PATH: String`, ...) or `nil` when no constant entry
       # exists for `name` in the loaded RBS environment. Callers MUST treat the return value as authoritative
@@ -2871,15 +2925,16 @@ module Rigor
       #
       # So the rescue only remembers, keyed by the `::`-stripped name (the eager walk spells it `::Acme`,
       # a dispatch site spells it `Acme`, and they are one class — the {#synthesized_namespaces}
-      # convention), and {#report_definition_build_failure} decides. First writer wins: the instance and
-      # singleton sides fail for the same underlying collision, and the first is the one a caller hit.
+      # convention), and {#report_definition_build_failure} decides. Every side's detail is kept, not the
+      # first one written (issue #1902): the instance and singleton sides can fail for DIFFERENT reasons
+      # (a duplicated `def self.s` and a duplicated `def i` on one class), and which side a run demands first
+      # depends on which files it analysed, so first-writer-wins made the reported tuple — and with it the
+      # message's "First failure", advice and file list — differ between a cold run and a warm recheck.
       def store_definition_build_detail(class_name, error)
         key = class_name.to_s.delete_prefix("::")
-        details = (@state[:definition_build_details] ||= {})
-        return if details.key?(key)
-
-        details[key] = [key, error.class.name.to_s, definition_build_member(error),
-                        definition_build_conflict_buffers(error), unresolved_type_name_detail(error)].freeze
+        details = ((@state[:definition_build_details] ||= {})[key] ||= [])
+        details << [key, error.class.name.to_s, definition_build_member(error),
+                    definition_build_conflict_buffers(error), unresolved_type_name_detail(error)].freeze
       end
 
       # Issue #997 — the `RBS::NoTypeFoundError` twin of {#definition_build_member}: `nil` for every other
@@ -2954,14 +3009,28 @@ module Rigor
         return if details.nil?
 
         key = class_name.to_s.delete_prefix("::")
-        detail = details[key]
-        return if detail.nil?
+        return if details[key].nil?
 
         reported = (@state[:definition_build_reported] ||= {})
         return if reported[key]
 
         reported[key] = true
-        (@state[:definition_build_failures] ||= []) << detail
+        attempt_both_definition_sides(class_name)
+        canonical = details[key].min_by { |candidate| self.class.definition_build_detail_order(candidate) }
+        (@state[:definition_build_failures] ||= []) << canonical
+      end
+
+      # Issue #1902 — a reported class's tuple is chosen from BOTH sides' failures, so the side this demand
+      # did not ask for is built here too. Without it, the candidate set would be whatever sides the run
+      # happened to demand, and a recheck whose closure touches only `Berry.s` would report the singleton
+      # side's reason where the full run, which also demanded `Berry.new.i`, reported the instance side's.
+      # An internal demand: it decides WHICH reason is shown for a class the analysis already demanded, never
+      # WHETHER a class is reported, so the set #696 binds to the analysis's own demand is unchanged.
+      def attempt_both_definition_sides(class_name)
+        during_internal_demand do
+          instance_definition(class_name)
+          singleton_definition(class_name)
+        end
       end
 
       # Marks a definition demand that is RIGOR'S OWN, not the analysed program's, so

data/lib/rigor/environment/required_features.rb

@@ -51,7 +51,8 @@ module Rigor
       #
       # @param sources — path => source text, read in place of that path's file (an editor buffer).
       def for_configuration(configuration, extra_files = [], sources: {})
-        files = Analysis::PathExpansion.ruby_files(configuration.paths, configuration.exclude_patterns)
+        files = Analysis::PathExpansion.ruby_files(configuration.paths, configuration.exclude_patterns,
+                                                   base: configuration.exclude_base)
         scan(files + Array(extra_files).map(&:to_s), sources: sources)
       rescue StandardError
         []
@@ -77,7 +78,8 @@ module Rigor
       # @return path (absolute) => the features that file requires, for every file under the configured paths
       #   that requires any. A long-lived reader (the language server) keeps this and overlays its open buffers.
       def feature_files(configuration)
-        listed = Analysis::PathExpansion.ruby_files(configuration.paths, configuration.exclude_patterns)
+        listed = Analysis::PathExpansion.ruby_files(configuration.paths, configuration.exclude_patterns,
+                                                    base: configuration.exclude_base)
         files = listed.map { |path| File.expand_path(path.to_s) }
         result = files.each_with_object({}) do |path, acc|
           features = memoized_features_in(path)

data/lib/rigor/environment.rb

@@ -97,7 +97,7 @@ module Rigor
       # for the overlay, instead of aborting the run outright (see {#hkt_registry}).
       @hkt_scan_failure = FailureSlot.new
       @constant_type_cache = ConstantTypeCacheHolder.new
-      # ADR-82 WD9 — `[gem_name, version]` pairs for the locked gems with no resolvable RBS. The
+      # ADR-82 WD9 — `[gem_name, version, variants]` entries for the locked gems with no resolvable RBS. The
       # root-constant ownership index over them is built lazily (first unresolved constant read) so runs
       # whose constants all resolve never pay the entry-file scan.
       @missing_rbs_gems = missing_rbs_gems.freeze
@@ -444,8 +444,8 @@ module Rigor
       end
 
       # The `:missing` classification (locked gems with no RBS through any resolution path), computed once
-      # and consumed twice: as `[gem_name, version]` pairs for the ADR-82 WD9 constant-ownership index, and
-      # as the eligible-gem set for the ADR-72 overlay resolution. Returns `[pairs, overlay_paths]`.
+      # and consumed twice: as `[gem_name, version, variants]` entries for the ADR-82 WD9 constant-ownership
+      # index, and as the eligible-gem set for the ADR-72 overlay resolution. Returns `[entries, overlay_paths]`.
       def missing_gems_and_overlay_paths(locked:, default_libraries:, bundle_sig_paths:,
                                          rbs_collection_paths:, plugin_registry:, signature_paths: [],
                                          bundle_root: nil)
@@ -458,7 +458,7 @@ module Rigor
           missing_gem_names: rows.map(&:gem_name), plugin_registry: plugin_registry,
           signature_paths: signature_paths
         )
-        [rows.map { |row| [row.gem_name, row.version] }, overlays]
+        [index_entries(rows, locked), overlays]
       end
 
       # Issue #530 — a project with no `Gemfile.lock` still has gems on disk, and before this it handed the
@@ -472,7 +472,14 @@ module Rigor
         return [[], []] if installed.empty?
 
         rows = missing_rows(installed, default_libraries, bundle_sig_paths, rbs_collection_paths)
-        [rows.map { |row| [row.gem_name, row.version] }, []]
+        [index_entries(rows, installed), []]
+      end
+
+      # The constant-ownership index's input: each `:missing` row with every `[version, platform]` variant its
+      # gem was locked (or found installed) under, because Bundler installs the variant matching the host —
+      # `commonmarker-2.10.0-arm64-darwin/` under a lockfile whose representative is the `ruby` one (#1844).
+      def index_entries(rows, gems)
+        rows.map { |row| [row.gem_name, row.version, gems[row.gem_name]&.variants] }
       end
 
       def missing_rows(gems, default_libraries, bundle_sig_paths, rbs_collection_paths)

data/lib/rigor/inference/block_call_timing.rb

@@ -165,7 +165,12 @@ module Rigor
       # nothing for names this rare, and the block-return pass is no independent check here: it types a
       # self-call to an overridden `raise` as Kernel's `bot` too, so a missed override is a wrong `bot`.
       # {LastLine.reads_line?} declines on it the same way for `gets` and `readline`.
+      #
+      # Issue #1459 — the answer reads every project file's tables whole, so it records a `defines:<name>` edge
+      # whichever way it answers: an edit that makes a file start or stop defining the name re-checks the reader
+      # (`Incremental.changed_defined_names`). A `pre_eval:` patch moves the snapshot's own fingerprint.
       def project_defines_anywhere?(method_name, scope)
+        Analysis::DependencyRecorder.read_missing(:defines, method_name) if Analysis::DependencyRecorder.active?
         return true if scope.top_level_def_for(method_name)
         # `discovered_methods` withholds a plain cross-file `def` (the ADR-17 monkey-patch contract); the
         # def-node tables still carry it, on both sides.

data/lib/rigor/inference/builtins/cruby_definers.rb

@@ -16,6 +16,9 @@ module Rigor
       # (`Integer#quo` and `File#to_path`, whose CRuby owners are `Numeric` and `IO`), and declares a few CRuby no
       # longer defines (`Process::Status#&`). A class no catalogue covers answers false, as does a method its
       # catalogue does not list: the caller reads both as "not proven". The catalogue is one CRuby snapshot.
+      #
+      # Issue #1752 — the singleton side reads the catalogue's `singleton_methods` (each `rb_define_singleton_method`
+      # on the class), the record that `Integer.sqrt` is CRuby's own method of `Integer`'s singleton class.
       module CRubyDefiners
         module_function
 
@@ -25,7 +28,15 @@ module Rigor
           !names.nil? && names.include?(method_name.to_s)
         end
 
-        def build_index
+        # Does the catalogue prove CRuby defines `method_name` on `class_name`'s singleton class itself?
+        def singleton_defines?(class_name, method_name)
+          names = SINGLETON_INDEX[class_name.to_s.delete_prefix("::")]
+          !names.nil? && names.include?(method_name.to_s)
+        end
+
+        # `{class name => Set[method name]}` from each catalogued class's instance methods and aliases, or from its
+        # `singleton_methods` when `side` is `:singleton`.
+        def build_index(side = :instance)
           index = Hash.new { |hash, key| hash[key] = Set.new }
           MethodCatalog.topic_paths.each do |path|
             data = YAML.safe_load_file(path, permitted_classes: [Symbol])
@@ -35,9 +46,7 @@ module Rigor
             classes.each do |name, klass|
               next if klass["rdoc_only"]
 
-              names = index[name]
-              names.merge(defined_names(klass["instance_methods"]))
-              names.merge(defined_names(klass["aliases"]))
+              merge_names(index[name], klass, side)
             end
           end
           Ractor.make_shareable(index.to_h { |name, names| [name, names.freeze] })
@@ -45,6 +54,13 @@ module Rigor
           Ractor.make_shareable({})
         end
 
+        def merge_names(names, klass, side)
+          return names.merge(defined_names(klass["singleton_methods"])) if side == :singleton
+
+          names.merge(defined_names(klass["instance_methods"]))
+          names.merge(defined_names(klass["aliases"]))
+        end
+
         # The names of `entries` CRuby defines at runtime: one the catalogue marks `rdoc_only` was registered only for
         # RDoc, inside an `#if 0` block.
         def defined_names(entries)
@@ -54,7 +70,8 @@ module Rigor
         end
 
         INDEX = build_index
-        private_constant :INDEX
+        SINGLETON_INDEX = build_index(:singleton)
+        private_constant :INDEX, :SINGLETON_INDEX
       end
     end
   end

data/lib/rigor/inference/captured_locals.rb

@@ -9,6 +9,7 @@ require_relative "index_write_widening"
 require_relative "mutation_widening"
 require_relative "optimistic_origin"
 require_relative "receiver_alias"
+require_relative "reflective_ivar_write"
 require_relative "unknown_store_widening"
 
 module Rigor
@@ -129,6 +130,9 @@ module Rigor
             if LOCAL_WRITE_NODES.include?(descendant.class)
               captured_local_write(descendant, ancestors, base_scope) { introduced ||= introduced_locals(block_node) }
             elsif outliving
+              if ReflectiveIvarWrite.unknown_target?(descendant)
+                (names ||= []).concat(reflective_unknown_ivars(base_scope))
+              end
               rebindable_outliving_write(descendant, base_scope, non_locals)
             end
           (names ||= []) << name if name
@@ -136,6 +140,13 @@ module Rigor
         names ? names.uniq : NO_NAMES
       end
 
+      # Issue #1889 — every ivar `base_scope` binds: an `instance_variable_set` on `self` whose target no literal
+      # names ({ReflectiveIvarWrite.unknown_target?}) may write any of them. One on its ADR-58 declaration seed
+      # counts too, since the census behind the seed sees no reflective write; {.bind} keeps its mark.
+      def reflective_unknown_ivars(base_scope)
+        base_scope.ivars.keys
+      end
+
       def rebindable_outliving_write(node, base_scope, non_locals)
         name = outliving_write_name(node, non_locals)
         name if name && rebindable_non_local?(base_scope, name)
@@ -151,8 +162,12 @@ module Rigor
         yield.include?(name) ? nil : name
       end
 
-      # The non-local `node` rebinds under `non_locals:` — or, without it, the instance variable only.
+      # The non-local `node` rebinds under `non_locals:` — or, without it, the instance variable only. A literal-name
+      # `instance_variable_set` on `self` ({ReflectiveIvarWrite.literal_name}) is a write of that ivar under either.
       def outliving_write_name(node, non_locals)
+        reflective = ReflectiveIvarWrite.literal_name(node)
+        return reflective if reflective
+
         name = non_local_write_name(node)
         non_locals || (name && ivar_name?(name) && NON_LOCAL_WRITE_NODES.include?(node.class)) ? name : nil
       end
@@ -201,13 +216,21 @@ module Rigor
       # it the miss answer the mark records (issue #1302).
       def bind(scope, name, type, optimistic: nil)
         case variable_kind(name)
-        when :ivar then OptimisticOrigin.carry_ivar_mark(scope, scope.with_ivar(name, type), name, optimistic)
+        when :ivar then bind_ivar(scope, name, type, optimistic)
         when :cvar then scope.with_cvar(name, type)
         when :global then scope.with_global(name, type)
         else OptimisticOrigin.carry_local_mark(scope, scope.with_local(name, type), name, optimistic)
         end
       end
 
+      # An ivar on its ADR-58 declaration seed reaches {.bind} through {.reflective_unknown_ivars}, and through
+      # `ExpressionTyper#prefix_answered_scope`; rebinding it re-stamps the declaration mark, as
+      # `ReflectiveIvarWrite.apply` does, so a nil in the seed fuels no nil-receiver diagnostic.
+      def bind_ivar(scope, name, type, optimistic)
+        bound = OptimisticOrigin.carry_ivar_mark(scope, scope.with_ivar(name, type), name, optimistic)
+        scope.declaration_sourced?(:ivar, name) ? bound.seed_declaration_sourced_ivar(name, type) : bound
+      end
+
       # The optimistic nil-freeness mark `scope` holds for a name from {.writes}, or nil.
       def optimistic_mark(scope, name)
         case variable_kind(name)
@@ -290,7 +313,7 @@ module Rigor
         receiver = node.receiver
         return true if receiver && MutationWidening::SHAPE_MUTATORS.include?(node.name)
 
-        callee_call?(node)
+        ReflectiveIvarWrite.self_write?(node) || callee_call?(node)
       end
 
       # Issue #1412 — {.content_mutations} for a `while` / `until` / `for` body: the locals bound in `base_scope`
@@ -310,23 +333,63 @@ module Rigor
 
       # The mutation sites under `body` whose reads name a variable {.captured_target?} accepts, keyed by name.
       # The block yields the names the enclosing construct introduces, asked only when a local site is found.
+      #
+      # A site whose receiver is a body local that aliases a capture (`l2 = log; l2 << e`) mutates that capture's
+      # object, so it is attributed to the capture as well ({.aliased_captures}): left out, the next iteration
+      # read `log` at its entry `[]` and `[1, 2].inject(0) { |a, e| r = a + log.size; l2 = log; l2 << e; r }`
+      # folded to `0` where Ruby answers `1` (issue #1332).
       def body_mutation_sites(body, base_scope, non_locals, &)
         sites = nil
         evaluator = nil
+        aliases = nil
         Source::NodeWalker.each_with_ancestors(body) do |descendant, ancestors|
           # A callee is resolved in the call-site scope, as the straight-line callee floor resolves it.
           site = mutation_site(descendant) { evaluator ||= StatementEvaluator.new(scope: base_scope) }
           next if site.nil?
 
           site_reads(site).each do |read|
-            next unless captured_target?(read, ancestors, base_scope, non_locals, &)
-
-            ((sites ||= {})[read.name] ||= []) << site
+            targets = captured_target?(read, ancestors, base_scope, non_locals, &) ? [read] : []
+            if read.is_a?(Prism::LocalVariableReadNode)
+              aliases ||= local_aliases(body)
+              targets.concat(aliased_captures(read.name, aliases, base_scope, non_locals, Set.new, &))
+            end
+            targets.each { |target| ((sites ||= {})[target.name] ||= []) << site }
           end
         end
         sites || NO_SITES
       end
 
+      # `{ name => [[read, ancestors], ...] }`: every variable read a local write under `body` may store
+      # ({ReceiverAlias.candidates} of its value), with the ancestors {.captured_target?} resolves it against.
+      def local_aliases(body)
+        aliases = {}
+        Source::NodeWalker.each_with_ancestors(body) do |node, ancestors|
+          next unless node.is_a?(Prism::LocalVariableWriteNode) || node.is_a?(Prism::LocalVariableOrWriteNode)
+
+          ReceiverAlias.candidates(node.value).each do |read|
+            (aliases[node.name] ||= []) << [read, ancestors + [node]]
+          end
+        end
+        aliases
+      end
+
+      # The captured reads the local `name` may alias, followed through local-to-local copies (`l3 = l2 = log`).
+      # It over-approximates — a write in any branch, or in a nested scope reusing the name, counts — which only
+      # widens a capture's binding.
+      def aliased_captures(name, aliases, base_scope, non_locals, visited, &)
+        return [] unless visited.add?(name)
+
+        aliases.fetch(name, NO_NAMES).flat_map do |read, ancestors|
+          if captured_target?(read, ancestors, base_scope, non_locals, &)
+            [read]
+          elsif read.is_a?(Prism::LocalVariableReadNode)
+            aliased_captures(read.name, aliases, base_scope, non_locals, visited, &)
+          else
+            NO_NAMES
+          end
+        end
+      end
+
       # The mutation site `node` is — the node itself, or a {UnknownStoreWidening::CalleeStore} for a self-call
       # whose callee content-mutates a local it is passed — or nil. A self-call is resolved by the
       # `StatementEvaluator` the block yields, which the caller builds only when one is needed. A mutator name