rigortype 0.4.4 → 0.4.5

data/lib/rigor/inference/unthreaded_rebinds.rb

@@ -23,7 +23,9 @@ module Rigor
     # - a statement, and the body of `(…)`, `begin` / `rescue` / `else` / `ensure`;
     # - an assignment's value — every variable-write form, and an index `||=` / `&&=` / `op=`, but not its
     #   receiver or index arguments;
-    # - an `if` / `unless` / `case` predicate and every branch, but not a `when` condition or an `in` guard;
+    # - an `if` / `unless` / `case` predicate and every branch, but not a `when` condition or an `in` guard (since
+    #   issue #1963 the evaluator threads a `when` test that runs code in a `case` with a subject; the scan does
+    #   not admit it yet, which floors a name needlessly rather than letting a pin through);
     # - both operands of `&&` / `||`;
     # - a `while` / `until` predicate and body, a `for` index, collection and body;
     # - a multi-assign value and its local and instance-variable targets, and the LOCAL a `rescue => e`

data/lib/rigor/lens/contract_reader.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "slot"
+require_relative "parameters"
 require_relative "../reflection"
 
 module Rigor
@@ -34,6 +35,26 @@ module Rigor
         unreadable("definition_build_failed", [])
       end
 
+      # The block an otherwise defaulted inline declaration (`rigor:v1:inferred-signature`) declares, as a
+      # `{required, type}` slot, or nil. The rbs-inline plugin defaults an unannotated `&block` to `?{ (?) ->
+      # untyped }`, so any other block came from a `# @rbs &block:` annotation, and `check` binds the block's
+      # parameters from it. A block spelled like the default carries nothing either way.
+      def read_defaulted_block(owner, scope, name, lookup_scope)
+        method = lookup(owner, scope, name, lookup_scope)
+        defs = method ? method.defs.select { |definition| definition.defined_in.to_s.delete_prefix("::") == owner } : []
+        return nil unless defs.size == 1 && annotations_of(method, defs).include?(INFERRED_SIGNATURE)
+
+        block = defs.first.type.block
+        return nil if block.nil? || default_block?(block)
+
+        provenance, path = @provenance.classify(buffer_name(defs.first))
+        return nil if provenance.nil?
+
+        { "required" => block.required, "type" => Slot.from_rbs(block_type(block), provenance, path) }
+      rescue StandardError
+        nil
+      end
+
       # The declared type of the constant `name` (qualified), as a slot with its declaration's provenance, or nil
       # when no RBS or inline declaration names it.
       def read_constant(name, environment)
@@ -102,14 +123,36 @@ module Rigor
       def overload(method_type, provenance, path, return_inferred, annotations)
         function = method_type.type
         params = function.respond_to?(:required_positionals) ? params_of(function, provenance, path) : nil
-        block = method_type.block && { "required" => method_type.block.required,
-                                       "type" => Slot.from_rbs(method_type.block.type.to_s, provenance, path) }
+        partly_defaulted = return_inferred && provenance == "inline"
+        block = method_type.block && block_slot(method_type.block, provenance, path, partly_defaulted)
         prefix = annotations.map { |string| "%a{#{string}} " }.join
         return_slot = return_inferred ? nil : Slot.from_rbs(function.return_type.to_s, provenance, path)
         { "rbs" => "#{prefix}#{method_type}", "params" => params, "block" => block, "return" => return_slot,
           "return_rbs" => function.return_type.to_s }
       end
 
+      # A block's function type as `RBS::MethodType#to_s` spells it inside the braces (`(Integer) -> void`, with a
+      # `[self: T]` binding when declared). Neither `RBS::Types::Function` nor `UntypedFunction` has a `to_s`.
+      def block_type(block)
+        self_binding = ::RBS::Types::SelfTypeBindingHelper.self_type_binding_to_s(block.self_type)
+        "(#{block.type.param_to_s}) #{self_binding}-> #{block.type.return_to_s}"
+      end
+
+      # Under an inline declaration the rbs-inline plugin defaulted in part (`partly_defaulted`), a block shaped
+      # like its default was not written: it reads as an undeclared block does.
+      def block_slot(block, provenance, path, partly_defaulted)
+        if partly_defaulted && default_block?(block)
+          return { "required" => false, "type" => Slot.dynamic("inferred", Parameters::UNDECLARED) }
+        end
+
+        { "required" => block.required, "type" => Slot.from_rbs(block_type(block), provenance, path) }
+      end
+
+      def default_block?(block)
+        !block.required && block.type.is_a?(::RBS::Types::UntypedFunction) && block.self_type.nil? &&
+          block.type.return_type.is_a?(::RBS::Types::Bases::Any)
+      end
+
       def params_of(function, provenance, path)
         (positional_params(function) + keyword_params(function)).map do |kind, name, param|
           { "name" => name&.to_s, "kind" => kind, "type" => Slot.from_rbs(param.type.to_s, provenance, path) }

data/lib/rigor/lens/document.rb

@@ -5,6 +5,7 @@ require "json"
 require_relative "../version"
 require_relative "../cache/engine_source"
 require_relative "../analysis/run_cache_key"
+require_relative "../rooted_glob"
 
 module Rigor
   module Lens
@@ -60,7 +61,7 @@ module Rigor
       end
 
       def signature_digest
-        listing = signature_roots.flat_map { |root| Dir.glob(File.join(root, "**", "*.rbs")) }.sort.map do |path|
+        listing = signature_roots.flat_map { |root| RootedGlob.glob(root, "**/*.rbs") }.sort.map do |path|
           "#{relative(path)}\t#{Lens.digest(File.binread(path))}\n"
         end
         Lens.digest(listing.join)

data/lib/rigor/lens/file_reader.rb

@@ -417,15 +417,25 @@ module Rigor
         fields.each do |field, field_node|
           # rbs-inline reads a `#:` trailing a field on its own line of a multi-line call as that field's type.
           trailing = field_node.location.start_line != start_line
+          members = attribute_members(field, attribute)
+          visibility = builder_field_visibility(members)
           add_site(field_node, { "kind" => "attribute", "name" => field, "owner" => name, "scope" => "instance",
-                                 "attribute" => attribute, "members" => attribute_members(field, attribute),
-                                 "module_function" => false, "visibility" => "public", "params" => nil,
+                                 "attribute" => attribute, "members" => members,
+                                 "module_function" => false, "visibility" => visibility, "params" => nil,
                                  "block" => nil, "body_return" => nil }, contracts: trailing ? :trailing : false)
         end
         block = node.value.block
         walk_body(block.body, nesting + [name], singleton: false, kind: :builder) if block&.body
       end
 
+      # Ruby forces a field reader named `initialize_copy` (say) private, but not its `Struct` writer: a `Data`
+      # field reads `private`, a `Struct` one, whose site covers both, `null`.
+      def builder_field_visibility(members)
+        return "public" unless members.intersect?(FORCED_PRIVATE)
+
+        members.all? { |member| FORCED_PRIVATE.include?(member) } ? "private" : nil
+      end
+
       # Whether a constant, class or module written here lands somewhere the nesting does not name: a builder
       # block, which Ruby `class_eval`s (defs go to the new class, but constants stay with the lexical scope), or a
       # `class << self` body (constants go to the singleton class). Such a declaration is an omission.

data/lib/rigor/lens/members.rb

@@ -14,10 +14,13 @@ module Rigor
       # @param contracts — `{[owner, scope, name] => ContractReader::Contract or nil}`
       # @param elsewhere — callable `(owner, scope, name) -> [{path, line}]`: other project files defining it
       # @param site_paths — `{site key => absolute path of its file}`, to match an inline contract's buffer
-      def initialize(sites:, omissions:, contracts:, elsewhere:, site_paths:)
+      # @param defaulted_blocks — `{[owner, scope, name] => {required, type}}`: the block a member's otherwise
+      #   defaulted inline declaration declares (ContractReader#read_defaulted_block)
+      def initialize(sites:, omissions:, contracts:, elsewhere:, site_paths:, defaulted_blocks: {})
         @sites = sites
         @omissions = omissions
         @contracts = contracts
+        @defaulted_blocks = defaulted_blocks
         @elsewhere = elsewhere
         @site_paths = site_paths
       end
@@ -115,11 +118,22 @@ module Rigor
 
         params, block, head = Parameters.read(node.parameters, yields: Parameters.yields?(node.body))
         slot = inferred_return(single, scope)
-        block_rbs = block ? " ?{ (?) -> untyped }" : ""
+        declared = !site.data["alias_of"] && @defaulted_blocks[[site.data["owner"], scope, name]]
+        block = declared || block
+        block_rbs = block_spelling(block, declared)
         { "rbs" => "#{head}#{block_rbs} -> #{return_spelling(slot)}", "params" => params, "block" => block,
           "return" => slot }
       end
 
+      # A block an otherwise defaulted declaration declares reads as declared (`{ (Integer) -> void }`); one the
+      # definition merely takes reads as `?{ (?) -> untyped }`.
+      def block_spelling(block, declared)
+        return "" if block.nil?
+        return " ?{ (?) -> untyped }" unless declared
+
+        " #{'?' unless declared['required']}{ #{declared['type']['type']} }"
+      end
+
       # An alias whose original Rigor cannot pin to one `def`: nothing about its signature is known.
       def unknown_overload
         { "rbs" => nil, "params" => nil, "block" => nil, "return" => Slot.unavailable("not_computed") }

data/lib/rigor/lens/run.rb

@@ -78,6 +78,7 @@ module Rigor
       def reset_captures
         @captured = {}
         @contracts = {}
+        @defaulted_blocks = {}
         @site_paths = {}
       end
 
@@ -145,18 +146,39 @@ module Rigor
           if published
             published_slot(published, scope.environment)
           else
-            declared_slot(site, contract_reader(scope.environment).read_constant(name, scope.environment))
+            declared_slot(site, contract_reader(scope.environment).read_constant(name, scope.environment), scope)
           end
       end
 
       # The rbs-inline plugin declares every constant of a file it reads, typing an unannotated one from its
       # literal (`[]` as `Array[untyped]`), and reads only a `#:` trailing the assignment as its type: an inline
-      # declaration is the constant's own only when that is the site's one contract comment.
-      def declared_slot(site, declared)
+      # declaration is the constant's own only when that is the site's one contract comment. Otherwise it is the
+      # plugin's default, which `check` reads all the same: that type, `inferred`. A `Class.new` / `Module.new`
+      # value is the exception, which `check` types through its own write reading, not the default `untyped`.
+      # An inline declaration from another file says nothing about this site: when the name is written in two
+      # files, the one the environment kept decides, and this site's own comment may say otherwise.
+      def declared_slot(site, declared, scope)
         return Slot.unavailable("not_computed") if declared.nil?
-        return Slot.unavailable("not_computed") if declared["provenance"] == "inline" && !trailing_type?(site)
+        return declared unless declared["provenance"] == "inline"
+        return Slot.unavailable("not_computed") unless own_inline_declaration?(site, scope)
+        return declared if trailing_type?(site)
+        return Slot.unavailable("not_computed") if anonymous_namespace?(site.node.value)
 
-        declared
+        published_slot(scope.environment.constant_for_name(site.data["name"]), scope.environment)
+      end
+
+      def own_inline_declaration?(site, scope)
+        buffer = scope.environment.rbs_loader&.constant_declaration(site.data["name"])&.last
+        path = @site_paths.fetch(site.data["key"])
+        buffer&.end_with?(":#{path}") || false
+      end
+
+      def anonymous_namespace?(node)
+        return false unless node.is_a?(Prism::Node)
+        return true if node.is_a?(Prism::CallNode) && node.name == :new && node.receiver &&
+                       %w[Class Module].include?(node.receiver.slice.delete_prefix("::"))
+
+        node.compact_child_nodes.any? { |child| anonymous_namespace?(child) }
       end
 
       def trailing_type?(site)
@@ -166,6 +188,7 @@ module Rigor
       end
 
       def published_slot(type, environment)
+        return Slot.unavailable("not_computed") if type.nil?
         return Slot.dynamic("inferred", nil) if type.is_a?(Type::Dynamic)
 
         spelled = speller(environment).call(type, nil)
@@ -178,7 +201,11 @@ module Rigor
         key = [owner, member_scope, name]
         return if @contracts.key?(key)
 
-        @contracts[key] = contract_reader(scope.environment).read(owner, member_scope.to_sym, name, scope)
+        reader = contract_reader(scope.environment)
+        @contracts[key] = reader.read(owner, member_scope.to_sym, name, scope)
+        return if @contracts[key]
+
+        @defaulted_blocks[key] = reader.read_defaulted_block(owner, member_scope.to_sym, name, scope)
       end
 
       def target(entry, diagnostics, session)
@@ -229,7 +256,7 @@ module Rigor
         sites = readers.values.flat_map(&:sites)
         omissions = readers.values.flat_map(&:omissions)
         requested = readers.keys.to_set
-        Members.new(sites: sites, omissions: omissions, contracts: @contracts,
+        Members.new(sites: sites, omissions: omissions, contracts: @contracts, defaulted_blocks: @defaulted_blocks,
                     elsewhere: elsewhere(session, requested), site_paths: @site_paths).build
       end
 

data/lib/rigor/mcp/server.rb

@@ -128,8 +128,8 @@ module Rigor
             properties: {
               rule: {
                 type: "string",
-                description: "Rule ID, legacy alias, or family prefix (call, flow, assert, dump, def). " \
-                             "Omit to list every rule."
+                description: "Rule ID, legacy alias, or family prefix (call, flow, def, assert, dump, global, " \
+                             "suppression, static, effect). Omit to list every rule."
               }
             }
           }

data/lib/rigor/plugin/base.rb

@@ -13,6 +13,7 @@ require_relative "../cache/engine_source"
 # plugin class body can be evaluated before anything else pulled the cache layer in.
 require_relative "../cache/store"
 require_relative "../source/node_walker"
+require_relative "../rooted_glob"
 
 module Rigor
   module Plugin
@@ -1003,7 +1004,7 @@ module Rigor
       # plugin code calls `watch:`.
       #
       # @param roots — search roots (relative to the project root, or absolute paths)
-      # @param patterns — glob suffixes joined under each root via `File.join(root, pattern)`.
+      # @param patterns — glob suffixes matched under each root, the root read literally (#1956).
       #   Multiple patterns union into one descriptor (`"**/*.erb", "**/*.html"` etc.).
       def glob_descriptor(roots, *patterns)
         files = collect_glob_files(Array(roots), patterns)
@@ -1163,7 +1164,7 @@ module Rigor
           absolute = File.absolute_path(root.to_s)
           next [] unless File.directory?(absolute)
 
-          patterns.flat_map { |pattern| Dir.glob(File.join(absolute, pattern.to_s)) }
+          patterns.flat_map { |pattern| RootedGlob.glob(absolute, pattern) }
         end
         matched.uniq.sort.select { |path| File.file?(path) }
       end

data/lib/rigor/plugin/io_boundary.rb

@@ -3,6 +3,7 @@
 require "digest"
 
 require_relative "access_denied_error"
+require_relative "../rooted_glob"
 
 module Rigor
   module Plugin
@@ -33,6 +34,8 @@ module Rigor
     #   for a plugin that asks "which of these N candidate files exists here?" — rigor-actionpack tries
     #   nine template extensions per `render` call — where N per-path probe rows would put thousands of
     #   validations on every warm run and one listing row puts one per directory.
+    # - `#list_directory_kinds(path)` — the KIND-aware listing (#1959): each entry with its `lstat` kind, and one
+    #   `:kinds` row that moves when an entry appears, vanishes or changes kind under the same name.
     # - `#open_url(url)` — fetches the URL when the policy permits it (`network_policy: :allowlist` plus an
     #   `allowed_url_hosts` match) and raises {AccessDeniedError} otherwise. v0.1.2 ships the allowlist
     #   surface; the default project policy still has `network_policy: :disabled` so plugins that want network
@@ -189,7 +192,7 @@ module Rigor
       # @return the absolute paths directly under `path` in `Dir.glob` order; empty when not a directory
       def list_directory(path)
         absolute = File.absolute_path(path.to_s)
-        entries = Dir.glob(File.join(absolute, "*"))
+        entries = RootedGlob.glob(absolute, "*")
         unless @policy.allow_read?(absolute)
           record_refusal(absolute)
           return entries
@@ -199,6 +202,34 @@ module Rigor
         entries
       end
 
+      # Issue #1959 — the KIND-aware listing. Returns each entry directly under `path` with what it is, a symlink
+      # not followed ({Cache::Descriptor::GlobEntry.lstat_kind}: `:file`, `:directory`, `:symlink` or `:other`, and
+      # `:absent` for an entry that vanished between the listing and its `lstat`),
+      # and records one `:kinds` {Cache::Descriptor::GlobEntry} over `path/*`. The row reads stale when an entry
+      # appears, disappears, or keeps its name and changes kind; NOT when an entry's bytes or stat tuple move, nor
+      # when anything below a subdirectory changes. It is the row for a walk that decides per top-level entry
+      # whether to descend: rigor-ffi skips `vendor/` and does not follow a symlinked directory, so a file `gen`
+      # replaced by a directory `gen/`, or a symlink replaced by a real directory, changes what it reads while
+      # every name stays put. {#list_directory}'s `:stat` row leaves directories out, and {#glob}'s `:names` row
+      # reads names alone.
+      #
+      # Like {#list_directory}, dot entries are not listed, and an out-of-policy directory is listed truthfully
+      # and contributes no row.
+      #
+      # @param path — project directory; relative paths expand against the working directory
+      # @return a Hash from each absolute entry path, in `Dir.glob` order, to its kind; empty when not a directory
+      def list_directory_kinds(path)
+        absolute = File.absolute_path(path.to_s)
+        entries = RootedGlob.glob(absolute, "*").to_h { |entry| [entry, Cache::Descriptor::GlobEntry.lstat_kind(entry)] }
+        unless @policy.allow_read?(absolute)
+          record_refusal(absolute)
+          return entries
+        end
+
+        record_glob_entry(absolute, "*", mode: :kinds)
+        entries
+      end
+
       # Issue #1652 — the MEMBERSHIP fingerprint of a `Dir.glob` pattern under `root`, `**` included. Returns the
       # matching paths and records one `:names` {Cache::Descriptor::GlobEntry} over `root` and `pattern`: the row
       # reads stale when a match appears or disappears, in a subdirectory created after the read too, and NOT
@@ -209,8 +240,13 @@ module Rigor
       #
       # The pattern must stay under `root`, since the policy is checked against `root` alone: a `..` segment, a
       # brace (`{..,x}`) or a backslash escape (`.\\./`) raises {AccessDeniedError} (`:read_outside_scope`).
-      # The last two are refused outright because `Dir.glob` can spell `..` with them. Out of policy, `root` is
-      # globbed truthfully and contributes no row, as in {#list_directory}.
+      # The last two are refused outright because `Dir.glob` can spell `..` with them. A leading `/` is read under
+      # `root`, as the joined spelling always read it (`/lib/**/*.rb` is `root/lib/**/*.rb`). Out of policy, `root`
+      # is globbed truthfully and contributes no row, as in {#list_directory}.
+      #
+      # `root` is read literally (#1959): {RootedGlob} escapes its glob metacharacters before the join, so a root
+      # spelled `fx[1]` or a directory named `{..,zz}` neither matches a sibling nor leaves itself.
+      # {#list_directory} lists the same way, and {Cache::Descriptor::GlobEntry} re-globs the row the same way.
       #
       # @param root — project directory; relative paths expand against the working directory
       # @param pattern — a `Dir.glob` pattern relative to `root`, such as `"ext/**/extconf.rb"`
@@ -227,7 +263,7 @@ module Rigor
           )
         end
 
-        entries = Dir.glob(File.join(absolute, pattern))
+        entries = RootedGlob.glob(absolute, pattern)
         unless @policy.allow_read?(absolute)
           record_refusal(absolute)
           return entries
@@ -390,8 +426,8 @@ module Rigor
         self.class.attribute(entry)
       end
 
-      # ADR-45 WD1c (#629) — the listing row for {#list_directory} (and the `:names` row for {#glob}),
-      # deduplicated per (root, pattern, mode) slot.
+      # ADR-45 WD1c (#629) — the listing row for {#list_directory} (and the `:names` row for {#glob} and the
+      # `:kinds` row for {#list_directory_kinds}), deduplicated per (root, pattern, mode) slot.
       # Recomputed on each call rather than `||=`d, so a directory listed again after a mid-run mutation
       # carries the signature of the state the LAST reader saw.
       def record_glob_entry(root, pattern, mode: :stat)

data/lib/rigor/plugin/isolation.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "box"
+require_relative "../rooted_glob"
 
 module Rigor
   module Plugin
@@ -74,8 +75,8 @@ module Rigor
       # requiring the gem, which is what the caller is about to do.
       def bundle_require_paths(bundle_root)
         bundle_gem_dirs(bundle_root).flat_map do |gem_home|
-          specs = Dir.glob(File.join(gem_home, "specifications", "*.gemspec"))
-                     .filter_map { |file| Gem::Specification.load(file) }
+          specs = RootedGlob.glob(gem_home, "specifications/*.gemspec")
+                            .filter_map { |file| Gem::Specification.load(file) }
           specs.group_by(&:name)
                .flat_map { |_, versions| versions.max_by(&:version).full_require_paths }
         end
@@ -88,7 +89,7 @@ module Rigor
         return [] if bundle_root.nil? || bundle_root.to_s.empty?
 
         root = bundle_root.to_s
-        (Dir.glob(File.join(root, "ruby", "*")) + [root])
+        (RootedGlob.glob(root, "ruby/*") + [root])
           .select { |dir| File.directory?(File.join(dir, "specifications")) }
       end
 

data/lib/rigor/protection/discovery_seed.rb

@@ -2,6 +2,7 @@
 
 require_relative "../inference/parameter_inference_collector"
 require_relative "../inference/scope_indexer"
+require_relative "../inference/project_seed_tables"
 
 module Rigor
   module Protection
@@ -80,47 +81,19 @@ module Rigor
         seed_tables(index).freeze
       end
 
-      # The whole-project discovery tables, from the single-walk combined pass (one parse per file, both
-      # collectors driven over the same tree) that {Analysis::Runner::ProjectPrePasses#discover} uses. Empty
-      # tables are dropped so an empty seed stays `{}` and every consumer's "seed nothing" branch keeps working.
-      #
-      # `discovered_class_sources` is carried as the runner carries it on every run: Tier 2 never records edges,
-      # but an ancestor-order reader asks whether a class is declared in more than one file. The mixin tables
-      # (`discovered_includes`, `discovered_prepends`, `discovered_extends`) ride the same fold, so a singleton
-      # `extend` reads the same from a per-file scope under coverage and protection as it does under `check`.
+      # The whole-project discovery tables, from the single-walk combined pass (one parse per file) that
+      # {Analysis::Runner::ProjectPrePasses#discover} uses, mapped by the one list {Inference::ProjectSeedTables}
+      # keeps (issue #1614). Empty tables are dropped so an empty seed stays `{}` and every consumer's "seed nothing"
+      # branch keeps working.
       def discovery_tables(paths)
         seed_tables(Inference::ScopeIndexer.discovered_project_index_for_paths(paths))
       end
 
-      # Maps a `{ classes:, def_index: }` discovery index onto the {Scope::DiscoveryIndex} slot names both
-      # consumers take. Shared by the whole-walk ({#discovery_tables}) and bundle-fold ({#tables_for_buffer})
-      # producers so a mutant's seed and the parent's seed can never disagree about shape.
+      # Maps a `{ classes:, def_index: }` discovery index onto the {Scope::DiscoveryIndex} slot names both consumers
+      # take. Shared by the whole-walk ({#discovery_tables}) and bundle-fold ({#tables_for_buffer}) producers so a
+      # mutant's seed and the parent's seed can never disagree about shape.
       def seed_tables(index)
-        def_index = index.fetch(:def_index)
-        tables = { discovered_classes: index.fetch(:classes) }
-        %i[
-          def_nodes def_nestings singleton_def_nodes def_sources singleton_def_sources superclasses includes
-          extends prepends unpositioned_mixins class_sources
-          method_visibilities methods parameter_envelopes data_member_layouts struct_member_layouts
-          deferred_ranges refinements global_write_census
-        ].each do |slot|
-          tables[seed_key(slot)] = def_index.fetch(slot)
-        end
-        # ADR-119 WD1 — the pairs travel as one: an unpaired empty table is dropped here, a pair only when both
-        # halves are empty (`compact_pairs`), so a non-empty sibling is never stranded by an empty member.
-        tables.merge!(def_index.fetch(:siblings))
-        Scope::DiscoveryIndex.compact_pairs(
-          tables.reject { |name, table| !Scope::DiscoveryIndex.paired?(name) && (table.nil? || table.empty?) }
-        )
-      end
-
-      UNPREFIXED_SLOTS = %i[data_member_layouts struct_member_layouts unpositioned_mixins].freeze
-      private_constant :UNPREFIXED_SLOTS
-
-      # The def-index slot names match the {Scope::DiscoveryIndex} ones under a `discovered_` prefix, except the
-      # two member-layout tables and the unpositioned-mixin table, which carry the same name on both sides.
-      def seed_key(slot)
-        UNPREFIXED_SLOTS.include?(slot) ? slot : :"discovered_#{slot}"
+        Inference::ProjectSeedTables.from_index(index)
       end
     end
   end

data/lib/rigor/protection/mutation_cache.rb

@@ -209,7 +209,13 @@ module Rigor
         def table_digest(project_scan)
           payload = {
             "synthetic" => project_scan.synthetic_method_index.to_h,
-            "patched" => patched_rows(project_scan.project_patched_methods)
+            "patched" => patched_rows(project_scan.project_patched_methods),
+            "patched_mixins" => project_scan.project_patched_methods.mixins.map do |mixin|
+              mixin.to_h.values.map(&:to_s)
+            end,
+            "patched_overrides" => project_scan.project_patched_methods.overrides.map do |key, visibility|
+              [*key, visibility].map(&:to_s)
+            end
           }
           Digest::SHA256.hexdigest(JSON.generate(payload))
         rescue StandardError
@@ -221,7 +227,7 @@ module Rigor
         def patched_rows(patched)
           patched.by_key.map do |(class_name, method_name, kind), entry|
             [class_name.to_s, method_name.to_s, kind.to_s, entry.source_path.to_s, entry.source_line,
-             entry.return_type&.describe(:short).to_s, entry.alias_of.to_s]
+             entry.return_type&.describe(:short).to_s, entry.alias_of.to_s, entry.visibility.to_s]
           end.sort
         end
 

data/lib/rigor/rooted_glob.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Rigor
+  # `Dir.glob(File.join(root, pattern))` with `root` read as a literal path (#1956, #1959).
+  #
+  # Joining a directory into the pattern makes `Dir.glob` read the directory's own characters as glob syntax:
+  # a project at `ds [x]` or `ds{a}` matches nothing, `ds*` matches its siblings, `fx[1]` matches `fx1`, and
+  # a directory literally named `{..,zz}` expands into the parent tree. Each glob metacharacter of `root` is
+  # backslash-escaped before the join, so `root` matches only itself while `pattern` keeps exactly the meaning the
+  # joined spelling gave it: a leading `/` collapses into the join (`/etc/*` reads `root/etc/*`), and so does one
+  # inside a brace alternative (`{/etc,lib}/*` reads `root/etc/*` and `root/lib/*`). `Dir.glob(pattern, base:)`
+  # would not do that: it reads an absolute pattern, or an absolute alternative, outside `base`. A root without
+  # metacharacters is joined unchanged, so the results are the joined glob's strings in its order, `root` kept as
+  # given (relative, symlinked or with a trailing `/`).
+  module RootedGlob
+    METACHARACTERS = /[\[\]{}*?\\]/
+
+    module_function
+
+    # @param root — a directory path (String or Pathname), taken literally
+    # @param pattern — a `Dir.glob` pattern relative to `root`
+    # @return the matches spelled under `root`, in `Dir.glob` order; empty when `root` is not a directory
+    def glob(root, pattern)
+      Dir.glob(File.join(root.to_s.gsub(METACHARACTERS, "\\\\\\0"), pattern.to_s))
+    end
+  end
+end

data/lib/rigor/scope/discovery_index.rb

@@ -231,6 +231,11 @@ module Rigor
       # (the meta-new walk does not route `Parent` through ancestor discovery), so a reader that must place `K` in a
       # hierarchy reads its superclass as unknown, as it reads the `nil` the table records for `class K < <expr>`.
       ENVELOPE_META_SUPERCLASS_MARK = :"<meta-superclass>"
+      # Issue #1979 — the kind of a `[ENVELOPE_CONSTRUCTED_KIND, constant_name]` bucket entry: `class K < <expr>` whose
+      # superclass expression is a core constructor call (`Data.define(...)`, `Struct.new(...)`, `Class.new(...)`)
+      # naming that constant, as the receiver or as `Class.new`'s single bare-constant argument (`Object` for none).
+      # Read only by the #1596 proof's subclass walk (`RefinedDispatch::OwnMethod.each_subclass`).
+      ENVELOPE_CONSTRUCTED_KIND = :constructed_from
       ENVELOPE_MODULE_MARK = :"<module>"
       ENVELOPE_DYNAMIC_MARK = :"<dynamic>"
       ENVELOPE_OBJECT_EXTENDED_MARK = :"<object-extended>"

data/lib/rigor/scope/resolution_chain/relevance.rb

@@ -84,6 +84,20 @@ module Rigor
           false
         end
 
+        # {.external_lacks?} on the side an entry stands for: an external superclass on a singleton chain
+        # (`:singleton`, its whole tail) is asked for a singleton method, an extended module (`:instance`) and every
+        # instance-side entry for an instance method.
+        def external_lacks_on?(scope, candidates, side, name)
+          return external_lacks?(scope, candidates, name) if side == :instance
+
+          known = candidates.find { |candidate| Rigor::Reflection.rbs_class_known?(candidate, scope: scope) }
+          return false if known.nil?
+
+          Rigor::Reflection.singleton_method_definition(known, name, scope: scope).nil?
+        rescue StandardError
+          false
+        end
+
         # One verdict's working state: the scope, the resolver, and the edges the tests read.
         class Context
           attr_reader :mark, :edges