rigortype 0.4.2 → 0.4.4

data/lib/rigor/lens/slot.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Lens
+    # Tagged type slots and RBS-buffer provenance (docs/internal-spec/lens.md § Slots).
+    module Slot
+      module_function
+
+      def typed(type, provenance, path: nil, from_site: nil)
+        { "state" => "typed", "type" => type, "provenance" => provenance, "path" => path, "from_site" => from_site }
+      end
+
+      def dynamic(provenance, cause, path: nil, from_site: nil)
+        { "state" => "dynamic", "type" => "untyped", "provenance" => provenance, "path" => path,
+          "from_site" => from_site, "cause" => cause&.to_s }
+      end
+
+      def unavailable(reason)
+        { "state" => "unavailable", "reason" => reason }
+      end
+
+      def unavailable?(slot)
+        slot.is_a?(Hash) && slot["state"] == "unavailable"
+      end
+
+      # A slot for an RBS type string read from a contract. `untyped` is a dynamic slot whose cause is the
+      # authored contract.
+      def from_rbs(type, provenance, path)
+        return dynamic(provenance, :explicit_untyped, path: path) if type == "untyped"
+
+        typed(type, provenance, path: path)
+      end
+
+      # The RBS type a slot puts in an overload's `rbs` string: an unavailable slot reads `untyped`.
+      def rbs_spelling(slot)
+        slot["state"] == "typed" ? slot["type"] : "untyped"
+      end
+    end
+
+    # Maps an RBS member's buffer name to a provenance (§ Slots).
+    class Provenance
+      CACHED_BUFFER = "<cached>"
+
+      # @param root — the project root (absolute)
+      # @param signature_roots — the project signature roots (absolute)
+      # @param plugin_roots — `{absolute signature directory => plugin id}` of the loaded plugins
+      def initialize(root:, signature_roots:, plugin_roots:)
+        @root = root
+        @signature_roots = signature_roots
+        @plugin_roots = plugin_roots
+      end
+
+      # [provenance, path] for a buffer name, or nil when the buffer cannot be classified.
+      def classify(buffer_name)
+        name = buffer_name.to_s
+        return ["inline", nil] if name.start_with?("virtual:rbs-inline:")
+        return ["plugin:#{name.split(':', 3)[1]}", nil] if name.start_with?("virtual:")
+        return nil if name.empty? || name == CACHED_BUFFER
+
+        absolute = File.expand_path(name, @root)
+        plugin = @plugin_roots.find { |root, _| under?(absolute, [root]) }
+        return ["plugin:#{plugin.last}", nil] if plugin
+        return ["sig", relative(absolute)] if under?(absolute, @signature_roots)
+
+        ["library", nil]
+      end
+
+      def relative(absolute)
+        Pathname(absolute).relative_path_from(Pathname(@root)).to_s
+      end
+
+      private
+
+      def under?(absolute, roots)
+        roots.any? { |root| absolute == root || absolute.start_with?("#{root}/") }
+      end
+    end
+  end
+end

data/lib/rigor/lens.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "hashing/xxh3"
+
+module Rigor
+  # `rigor lens`: a declaration map of the requested files with type provenance, computed as `rigor check` computes
+  # them (ADR-113; the output contract is docs/internal-spec/lens.md).
+  module Lens
+    SCHEMA = "lens/v0"
+    # Bumped on every breaking change to the `lens/v0` document (docs/internal-spec/lens.md § Status).
+    REVISION = 1
+    CAPABILITIES = %w[class module method attribute constant module_function builder alias body_return
+                      diagnostics inputs].freeze
+
+    module_function
+
+    # A Prism location as the document's span object: 1-based lines, 0-based byte columns and offsets.
+    def span(location)
+      { "start_line" => location.start_line, "start_column" => location.start_column,
+        "end_line" => location.end_line, "end_column" => location.end_column,
+        "start_offset" => location.start_offset, "end_offset" => location.end_offset }
+    end
+
+    # The span from the first to the last of a site's contract comments, or nil when it has none.
+    def contract_span(comments)
+      return nil if comments.empty?
+
+      first = comments.first.location
+      last = comments.last.location
+      { "start_line" => first.start_line, "start_column" => first.start_column, "end_line" => last.end_line,
+        "end_column" => last.end_column, "start_offset" => first.start_offset, "end_offset" => last.end_offset }
+    end
+
+    def digest(bytes)
+      "xxh3-64:#{Hashing::XXH3.file_hash(bytes)}"
+    end
+  end
+end
+
+require_relative "lens/run"
+require_relative "lens/document"

data/lib/rigor/mcp/server.rb

@@ -63,6 +63,25 @@ module Rigor
             }
           }
         },
+        {
+          name: "rigor_lens",
+          description: "Map the classes, modules, methods and attributes the given Ruby files declare, with the " \
+                       "type `rigor check` gives each one and where that type came from (sig/, an inline " \
+                       "comment, a plugin, a library, or inference). Returns the lens/v0 JSON document " \
+                       "(experimental). Pass every file you need in one call: each call pays one analysis run.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              files: {
+                type: "array",
+                items: { type: "string" },
+                description: "Ruby files to map (required)"
+              },
+              config: { type: "string", description: "Path to .rigor.yml (optional)" }
+            },
+            required: ["files"]
+          }
+        },
         {
           name: "rigor_annotate",
           description: "Return the given Ruby source file with each line's last-expression type " \
@@ -180,13 +199,12 @@ module Rigor
         out_io = StringIO.new
         err_io = StringIO.new
         require_relative "../cli"
-        exit_code = CLI.new(argv, out: out_io, err: err_io).run
-
-        is_error = exit_code == CLI::EXIT_USAGE
-        text = out_io.string
-        text = err_io.string if text.empty? && is_error
+        exit_code = with_captured_streams(out_io, err_io) { CLI.new(argv, out: out_io, err: err_io).run }
 
-        success(id, { content: [{ type: "text", text: text }], isError: is_error })
+        success(id, tool_result(out_io.string, err_io.string, exit_code))
+      rescue SystemExit => e
+        # Defence against any command that exits: it must not take the server down with it.
+        success(id, { content: [{ type: "text", text: "Command exited (status #{e.status})" }], isError: true })
       rescue StandardError => e
         @err.puts("rigor mcp: #{e.class}: #{e.message}")
         @err.puts(e.backtrace.first(5).join("\n")) if e.backtrace
@@ -196,6 +214,26 @@ module Rigor
                 })
       end
 
+      # A non-zero exit with nothing on stdout printed only an error; exit 1 with a document (check, lens) is a
+      # result, not an error.
+      def tool_result(out, err, exit_code)
+        is_error = [CLI::EXIT_USAGE, CLI::EXIT_INTERNAL_ERROR].include?(exit_code) || (out.empty? && !exit_code.zero?)
+        { content: [{ type: "text", text: out.empty? ? err : out }], isError: is_error }
+      end
+
+      # The JSON-RPC channel is the process's stdout, so nothing a command writes past its `out:` (an option
+      # parser's `--help`, a stray `puts`) may reach it while the command runs.
+      def with_captured_streams(out_io, err_io)
+        stdout = $stdout
+        stderr = $stderr
+        $stdout = out_io
+        $stderr = err_io
+        yield
+      ensure
+        $stdout = stdout
+        $stderr = stderr
+      end
+
       def build_argv(name, args) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/AbcSize,Metrics/PerceivedComplexity
         effective_config = args["config"] || @config_path
 
@@ -203,49 +241,52 @@ module Rigor
         when "rigor_check"
           argv = ["check", "--format=json", "--no-stats"]
           argv << "--config=#{effective_config}" if effective_config
-          argv += Array(args["paths"])
-          argv
+          argv + ["--", *Array(args["paths"])]
 
         when "rigor_type_of"
           return nil unless args["file"] && args["line"] && args["col"]
 
           argv = ["type-of", "--format=json"]
           argv << "--config=#{effective_config}" if effective_config
-          argv << "#{args['file']}:#{args['line']}:#{args['col']}"
-          argv
+          # `--` ends the options, so a file named like a flag is a file.
+          argv + ["--", "#{args['file']}:#{args['line']}:#{args['col']}"]
 
         when "rigor_triage"
           argv = ["triage", "--format=json"]
           argv << "--config=#{effective_config}" if effective_config
           argv << "--top=#{args['top']}" if args["top"]
-          argv += Array(args["paths"])
-          argv
+          argv + ["--", *Array(args["paths"])]
+
+        when "rigor_lens"
+          files = args["files"]
+          return nil unless files.is_a?(Array) && !files.empty? && files.all?(String)
+
+          argv = ["lens", "--format=json"]
+          argv << "--config=#{effective_config}" if effective_config
+          # `--` ends the options, so a file named like a flag (`--version`) is a file.
+          argv + ["--", *files]
 
         when "rigor_annotate"
           return nil unless args["file"]
 
           argv = ["annotate", "--no-color"]
           argv << "--config=#{effective_config}" if effective_config
-          argv << args["file"]
-          argv
+          argv + ["--", args["file"]]
 
         when "rigor_sig_gen"
           argv = ["sig-gen", "--print", "--format=json"]
           argv << "--config=#{effective_config}" if effective_config
           argv << "--params=#{args['params']}" if args["params"]
-          argv += Array(args["paths"])
-          argv
+          argv + ["--", *Array(args["paths"])]
 
         when "rigor_explain"
           argv = ["explain", "--format=json"]
-          argv << args["rule"] if args["rule"]
-          argv
+          args["rule"] ? argv + ["--", args["rule"]] : argv
 
         when "rigor_coverage"
           argv = ["coverage", "--format=json"]
           argv << "--config=#{effective_config}" if effective_config
-          argv += Array(args["paths"])
-          argv
+          argv + ["--", *Array(args["paths"])]
         end
       end
 

data/lib/rigor/plugin/box_probe.rb

@@ -15,7 +15,8 @@ module Rigor
     # under `RUBY_BOX=1` and must print the right answer. That admits a 4.1.0dev build with the fix and a
     # future 4.0.x that backports it, and refuses a development build cut before the fix — none of which a
     # `RUBY_VERSION` bound gets right. The probe costs one short-lived `ruby --disable-gems` process, paid
-    # only when a run opts into `ruby_box`.
+    # only when a run opts into `ruby_box` or starts with `RUBY_BOX` already set, and only once per Ruby
+    # build: {cached_unsupported_reason} remembers the verdict.
     #
     # Loaded by `exe/rigor` before anything else, so this file requires nothing from Rigor.
     module BoxProbe
@@ -36,20 +37,166 @@ module Rigor
       # counted as a failure, so a wedged probe cannot hang the launcher (or `rigor lsp` behind it).
       DEADLINE_SECONDS = 10
 
+      # Set on the environment of every re-exec this module asks for, so the re-exec'ed launcher neither
+      # probes again nor re-execs again. The launcher deletes it before Rigor loads, so nothing Rigor spawns
+      # inherits it.
+      REEXEC_MARKER = "RIGOR_BOX_PROBED"
+
+      # The signals the bug's NULL-box dereference ends a child with. A child killed by any other signal
+      # (an OOM killer's `SIGKILL`, an operator's `SIGTERM`) is still refused, but that verdict is not cached.
+      CRASH_SIGNALS = %w[SEGV BUS ABRT ILL].freeze
+
+      CACHE_FORMAT = "rigor-box-probe-v1"
+
       module_function
 
+      # Decides what `exe/rigor` does before Rigor loads, editing `env` (the real `ENV` in the launcher) in
+      # place. Returns true when the launcher must re-exec itself with `env` as now edited.
+      #
+      # - `RUBY_BOX` already set (by hand or by a wrapper), and `Ruby::Box` active in this process: the
+      #   process booted inside the box before any Rigor code ran, so on a Ruby without the Bug #22260 fix
+      #   the first Ractor-shareable lambda Rigor calls segfaults. Probe (through the cache); when the Ruby
+      #   is refused, print a notice, drop `RUBY_BOX` and the `ruby_box` request, and re-exec. When it
+      #   passes, keep `RUBY_BOX` as the user set it.
+      # - `ruby_box` requested and `RUBY_BOX` unset: probe; re-exec under `RUBY_BOX=1` when it passes,
+      #   otherwise warn and drop the request.
+      # - Otherwise nothing.
+      def needs_reexec?(env, stderr: $stderr, box_active: box_active?, cache_dir: default_cache_dir(env))
+        return false if env.delete(REEXEC_MARKER)
+
+        if env["RUBY_BOX"].to_s.empty?
+          reexec_for_box_request?(env, stderr, cache_dir)
+        else
+          reexec_without_preset_box?(env, stderr, box_active, cache_dir)
+        end
+      end
+
+      def reexec_for_box_request?(env, stderr, cache_dir)
+        isolation = env["RIGOR_PLUGIN_ISOLATION"].to_s
+        return false unless isolation == "ruby_box" || !env["RIGOR_BOX"].to_s.empty?
+
+        if (reason = cached_unsupported_reason(cache_dir: cache_dir))
+          # `puts` on stderr, not `warn`: `-W0` silences `warn`, and this fallback must never be silent.
+          stderr.puts "rigor: ruby_box plugin isolation is unavailable: #{reason}. " \
+                      "Falling back to the configured plugins_isolation strategy (default: process)."
+          drop_box_request(env)
+          false
+        else
+          env["RUBY_BOX"] = "1"
+          env["RIGOR_PLUGIN_ISOLATION"] = "ruby_box" if isolation.empty?
+          env[REEXEC_MARKER] = "1"
+          true
+        end
+      end
+
+      def reexec_without_preset_box?(env, stderr, box_active, cache_dir)
+        return false unless box_active
+
+        reason = cached_unsupported_reason(cache_dir: cache_dir)
+        return false unless reason
+
+        stderr.puts "rigor: RUBY_BOX is set, but #{reason}. " \
+                    "Re-running without RUBY_BOX; plugins will not run inside Ruby::Box."
+        env.delete("RUBY_BOX")
+        drop_box_request(env)
+        env[REEXEC_MARKER] = "1"
+        true
+      end
+
+      def drop_box_request(env)
+        env.delete("RIGOR_PLUGIN_ISOLATION") if env["RIGOR_PLUGIN_ISOLATION"].to_s == "ruby_box"
+        env.delete("RIGOR_BOX")
+      end
+
+      # Whether this process booted inside `Ruby::Box`. False on a Ruby without the feature, which ignores
+      # `RUBY_BOX`, so a preset variable there costs nothing.
+      def box_active?
+        return false unless defined?(::Ruby::Box) && ::Ruby::Box.respond_to?(:enabled?)
+
+        ::Ruby::Box.enabled? == true
+      end
+
+      # `$XDG_CACHE_HOME/rigor` when that is an absolute path, else `$HOME/.cache/rigor` when `HOME` is an
+      # absolute path (the passwd entry when `HOME` is unset); nil otherwise, which turns the cache off
+      # rather than writing under the working directory.
+      def default_cache_dir(env)
+        xdg = env["XDG_CACHE_HOME"].to_s
+        return File.join(xdg, "rigor") if xdg.start_with?("/")
+
+        home = env.key?("HOME") ? env["HOME"].to_s : Dir.home
+        File.absolute_path?(home) ? File.join(home, ".cache", "rigor") : nil
+      rescue ArgumentError
+        nil
+      end
+
+      # {unsupported_reason}, remembered per Ruby build so a launcher that probes on every run pays for the
+      # child process once. A pass is stored only when the child printed the right answer, and a refusal
+      # only when it is a property of the Ruby (no `Ruby::Box`, or a crash signal); a probe that could not
+      # run, timed out, or failed some other way is answered but not stored. An unreadable or corrupt
+      # cache file reads as a miss; a write that fails is ignored.
+      def cached_unsupported_reason(ruby = RbConfig.ruby, cache_dir:)
+        path = cache_dir && cache_path(cache_dir, ruby)
+        cached = path && read_cache(path)
+        return cached[:reason] if cached
+
+        reason, cacheable = verdict(ruby)
+        write_cache(path, reason) if path && cacheable
+        reason
+      end
+
+      # The cache file for `ruby`: keyed on the Ruby build that runs the launcher (its version, patch level,
+      # revision and description) together with the executable path and the probe script itself.
+      def cache_path(cache_dir, ruby)
+        require "digest/sha2"
+        key = [RUBY_VERSION, RUBY_PATCHLEVEL, RUBY_REVISION, RUBY_DESCRIPTION, File.expand_path(ruby), SCRIPT]
+        File.join(cache_dir, "ruby-box-probe", Digest::SHA256.hexdigest(key.join("\0")))
+      end
+
+      def read_cache(path)
+        format, verdict, reason = File.read(path).split("\n", 3)
+        return nil unless format == CACHE_FORMAT
+
+        case verdict
+        when "pass" then reason.nil? ? { reason: nil } : nil
+        when "fail" then reason.to_s.chomp.empty? ? nil : { reason: reason.chomp }
+        end
+      rescue SystemCallError, IOError, ArgumentError
+        nil
+      end
+
+      def write_cache(path, reason)
+        require "fileutils"
+        FileUtils.mkdir_p(File.dirname(path))
+        body = reason ? "#{CACHE_FORMAT}\nfail\n#{reason}\n" : "#{CACHE_FORMAT}\npass"
+        temp = "#{path}.#{::Process.pid}.tmp"
+        File.write(temp, body)
+        File.rename(temp, path)
+      rescue SystemCallError, IOError
+        nil
+      end
+
       # nil when `ruby` can run Rigor under `RUBY_BOX=1`; otherwise a short reason for the launcher's
       # warning. Only a child killed by a signal is blamed on the bug; any other failure to answer is
       # reported as the probe failing, never as a pass.
       def unsupported_reason(ruby = RbConfig.ruby)
+        verdict(ruby).first
+      end
+
+      # `[reason, cacheable]` — {unsupported_reason}'s answer, and whether it is a property of the Ruby
+      # build rather than of this one attempt.
+      def verdict(ruby)
         output, status = run(ruby)
-        return "the Ruby::Box probe could not run #{ruby}" if status.nil?
-        return nil if status.success? && output == EXPECTED_OUTPUT
-        return "Ruby::Box is not available in Ruby #{RUBY_VERSION}" if status.exitstatus == 2
-        return "the Ruby::Box probe failed (#{status})" unless status.signaled?
+        return ["the Ruby::Box probe could not run #{ruby}", false] if status.nil?
+        return [nil, true] if status.success? && output == EXPECTED_OUTPUT
+        return ["Ruby::Box is not available in Ruby #{RUBY_VERSION}", true] if status.exitstatus == 2
+        return ["the Ruby::Box probe failed (#{status})", false] unless status.signaled?
+
+        ["Ruby #{RUBY_VERSION} crashes running Ractor-shareable procs inside Ruby::Box " \
+         "(Ruby Bug #22260; a Ruby carrying its fix is needed)", crash_signal?(status.termsig)]
+      end
 
-        "Ruby #{RUBY_VERSION} crashes running Ractor-shareable procs inside Ruby::Box " \
-          "(Ruby Bug #22260; a Ruby carrying its fix is needed)"
+      def crash_signal?(signo)
+        CRASH_SIGNALS.any? { |name| Signal.list[name] == signo }
       end
 
       # `RUBYOPT` is cleared so a `-r` of the caller's (bootsnap, a debugger, a coverage hook) cannot fail

data/lib/rigor/project_environment.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "environment"
+require_relative "inference/project_patched_scanner"
 require_relative "plugin"
 require_relative "plugin/loader"
 require_relative "plugin/services"
@@ -55,9 +56,15 @@ module Rigor
     #   `source_rbs_synthesizer` runs over them at env-build time; an empty list contributes no synthesized RBS.
     # @param feature_sources — path => source text the required-feature scan reads in place of that file (an
     #   editor buffer bound with `--tmp-file` / `--instead-of`).
-    def build(configuration:, source_files:, feature_sources: {})
+    # @param project_patched_methods — the `pre_eval:` registry. Defaults to the configuration's own (see
+    #   {.project_patched_methods}), so every probe command (`type-scan`, `trace`, `annotate`, `sig-gen`) types a
+    #   patched method as `rigor check` does (issue #1895); `type-of` passes its buffer-aware one. An explicit
+    #   nil keeps the unpatched universe.
+    def build(configuration:, source_files:, feature_sources: {},
+              project_patched_methods: ProjectEnvironment.project_patched_methods(configuration))
       features = required_features(configuration, source_files, sources: feature_sources)
       Environment.for_project(
+        project_patched_methods: project_patched_methods,
         libraries: configuration.libraries,
         signature_paths: configuration.signature_paths,
         plugin_registry: load_plugin_registry(configuration),
@@ -69,6 +76,21 @@ module Rigor
       bare(configuration, features)
     end
 
+    # The patched-method registry `rigor check` types against for the project's `pre_eval:` files. It depends
+    # on those files alone, so it is built by the same {Inference::ProjectPatchedScanner} the Runner's project
+    # pre-pass calls, over the same resolved `configuration.pre_eval` entries (glob-expanded at config load,
+    # missing files skipped), without the pre-pass's plugin load / `#prepare` / dependency-source work. An
+    # editor `buffer` is honoured, so a `--tmp-file` edit of a pre_eval file is read in flight. Nil when the
+    # project lists no `pre_eval:` entry, so a project without one stays byte-identical. Fail-soft.
+    def project_patched_methods(configuration, buffer: nil)
+      return nil if configuration.pre_eval.empty?
+
+      existing = configuration.pre_eval.select { |path| File.file?(path) }
+      Inference::ProjectPatchedScanner.scan(existing, buffer: buffer).registry
+    rescue StandardError
+      nil
+    end
+
     # Issue #1700 — the {Environment::RequiredFeatures} the environment gates on: the configured paths plus
     # `extra_files` (the file a probe inspects, which may lie outside them), the same set `rigor check` scans
     # whichever files it is given, so a position types as `rigor check` types it.

data/lib/rigor/protection/mutation_cache.rb

@@ -84,7 +84,8 @@ module Rigor
 
       # Human-readable reasons the caller prints. Each names something the operator can act on.
       NO_SNAPSHOT = "no reusable `rigor check --incremental` snapshot"
-      OPAQUE_PLUGIN = "a plugin contributes types with no incremental fingerprint surface"
+      OPAQUE_PLUGIN = "a plugin is opaque to the incremental fingerprint " \
+                      "(no fingerprint surface, or a value it cannot digest)"
       UNDIGESTIBLE = "the project-scan tables could not be digested"
       UNIDENTIFIED_ENGINE = "the engine's own source tree could not be digested"
 

data/lib/rigor/scope.rb

@@ -251,11 +251,11 @@ module Rigor
     # class in a project that publishes nothing) allocates none.
     EMPTY_PUBLISHED_CONSTANT_IVARS = Set.new.freeze
     # The index `||=` sites of a repeating block body whose slot an earlier run of the body may have filled,
-    # keyed by node identity and laid by a block-return pass at the body's entry
-    # ({#with_repeated_or_writes}; `Inference::RepeatedOrWrites` decides which). The memoizing `||=` reading
-    # (`StatementEvaluator#index_compound_write_value`) is withheld at such a site. The mark belongs to the
-    # site, so no rebind or narrowing of a variable drops it, and a join keeps a site either arm holds: the
-    # mark only ever withholds that reading, whose answer is the narrower one.
+    # keyed by node identity and laid at the body's entry by a block-return pass or by `StatementEvaluator`'s
+    # statement and write-back passes ({#with_repeated_or_writes}; `Inference::RepeatedOrWrites` decides which).
+    # The memoizing `||=` reading (`StatementEvaluator#index_compound_write_value`) is withheld at such a site.
+    # The mark belongs to the site, so no rebind or narrowing of a variable drops it, and a join keeps a site
+    # either arm holds: the mark only ever withholds that reading, whose answer is the narrower one.
     EMPTY_REPEATED_OR_WRITES = {}.compare_by_identity.freeze
     # Issue #1429 — the narrowing a guard leaves on a constant reference (`STDOUT.is_a?(StringIO)`, `if CONFIG`),
     # keyed by the reference's spelling ({Inference::Narrowing.constant_key}: `"STDOUT"`, `"::Foo::BAR"`). A constant
@@ -457,6 +457,13 @@ module Rigor
       @locals[name.to_sym]
     end
 
+    # Issue #1840 — replaces the joined bindings of locals a branch merge only narrowed with their pre-branch
+    # binding ({Inference::UntypedRejoin}). Unlike {#with_local} this is not a write: the value is the one the
+    # branches started from, so every fact, narrowing and mark the join kept about it still holds.
+    def with_rejoined_locals(bindings)
+      rebuild(locals: @locals.merge(bindings).freeze)
+    end
+
     def with_local(name, type)
       bind_local(name, type, keep_marks: false)
     end
@@ -869,13 +876,18 @@ module Rigor
     STDOUT_ALIASES = { :$stdout => :$>, :$> => :$stdout }.freeze
     private_constant :STDOUT_ALIASES
 
-    # Issue #1429 — {#forget_guard_narrowings} for the one name `[kind, name]`.
+    # Issue #1429 — {#forget_guard_narrowings} for the one name `[kind, name]`. Issue #1596 — an `:ivar` kind too,
+    # for a self-call proven to write only some instance variables.
     def forget_guard_narrowing_of(kind, name)
       key = [kind, name]
       pre_guard = @guard_records[key]
       return self if pre_guard.nil?
 
-      if kind == :global
+      if kind == :ivar
+        current = @ivars[name]
+        ivars = current ? @ivars.merge(name => Type::Combinator.union(pre_guard, current)).freeze : @ivars
+        rebuild(ivars: ivars, guard_records: @guard_records.except(key).freeze)
+      elsif kind == :global
         current = @globals[name]
         globals = current ? @globals.merge(name => Type::Combinator.union(pre_guard, current)).freeze : @globals
         rebuild(globals: globals, guard_records: @guard_records.except(key).freeze)
@@ -1055,20 +1067,22 @@ module Rigor
       @repeated_or_writes.key?(node)
     end
 
-    # Regex match-data globals (`$~`, `$&`, `$1..$9`, the pre/post-match and last-paren back-references). Narrowed
+    # Regex match-data globals (`$~`, `$&`, `$1..$N`, the pre/post-match and last-paren back-references). Narrowed
     # on a successful-`=~` / `case`-`when` match edge (see `Narrowing#regex_match_predicate_scopes`). They live in
     # the method frame's special-variable slot, which the method's blocks and closures share (issue #1358), so a
     # later call that may run a match in this frame — a match-capable call, a block that may match, a call once
     # the frame has made a closure that may — rebinds every one of them, and `eval_call` forgets the narrowed
     # facts here. Always safe — only drops facts, so a subsequent read falls back to the default `String | nil`.
     # Program-level `$GLOBAL = ...` seeds use other names and are untouched.
-    MATCH_DATA_GLOBALS = %i[$~ $& $` $' $+ $1 $2 $3 $4 $5 $6 $7 $8 $9].freeze
-    private_constant :MATCH_DATA_GLOBALS
+    # Issue #1384 — the numbered groups are matched by name, not listed: a regex may carry more than nine captures, and
+    # `$10` and above are the same slot as `$1`..`$9`, so forgetting must clear them too.
+    MATCH_DATA_GLOBAL_NAME = /\A\$(?:~|&|`|'|\+|[1-9]\d*)\z/
+    private_constant :MATCH_DATA_GLOBAL_NAME
 
     def forget_match_globals
       return self unless match_globals_bound?
 
-      rebuild(globals: @globals.except(*MATCH_DATA_GLOBALS).freeze)
+      rebuild(globals: @globals.reject { |name, _| MATCH_DATA_GLOBAL_NAME.match?(name.name) }.freeze)
     end
 
     # Issue #1361 — this scope with every bound match-data global rebound to `Dynamic[top]`, and an unbound one left
@@ -1079,14 +1093,16 @@ module Rigor
       return self unless match_globals_bound?
 
       untyped = Type::Combinator.untyped
-      rebound = MATCH_DATA_GLOBALS.each_with_object({}) { |name, acc| acc[name] = untyped if @globals.key?(name) }
+      rebound = @globals.each_with_object({}) do |(name, _), acc|
+        acc[name] = untyped if MATCH_DATA_GLOBAL_NAME.match?(name.name)
+      end
       rebuild(globals: @globals.merge(rebound).freeze)
     end
 
     # True when any match-data global holds a binding, which a match edge or {#untyped_match_globals} makes: the only
     # state {#forget_match_globals} can drop, and so the gate on every scan that decides whether to.
     def match_globals_bound?
-      !@globals.empty? && MATCH_DATA_GLOBALS.any? { |name| @globals.key?(name) }
+      !@globals.empty? && @globals.any? { |name, _| MATCH_DATA_GLOBAL_NAME.match?(name.name) }
     end
 
     # Issue #1359 — the last line read, `$_`, lives in the same frame slot as the match globals, and so on the same
@@ -1910,10 +1926,10 @@ module Rigor
     private_constant :EMPTY_PARAMETER_ENVELOPES
 
     # v0.1.2 — per-class table mapping `method_name (Symbol) → :public | :private | :protected`. Populated by
-    # `ScopeIndexer` for every `def` it sees inside a class body, with the visibility taken from the surrounding
-    # `private` / `protected` / `public` modifier state plus any post-hoc `private :name, ...` named-argument
-    # calls. Consumed by the `def.method-visibility-mismatch` rule so explicit-non-self calls to a private method
-    # surface a diagnostic.
+    # `ScopeIndexer` for every `def` and `attr_*` member it sees inside a class body, with the visibility taken from
+    # a wrapping `private def` / `private attr_reader` call, else the surrounding `private` / `protected` / `public`
+    # modifier state, plus any post-hoc `private :name, ...` named-argument calls. Consumed by the
+    # `def.method-visibility-mismatch` rule so explicit-non-self calls to a private method surface a diagnostic.
     def discovered_method_visibility(class_name, method_name)
       table = @discovery.discovered_method_visibilities[class_name.to_s]
       return nil unless table