rigortype 0.4.4 → 0.4.6

data/lib/rigor/inference/synthetic_method_index.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "digest"
+
 require_relative "synthetic_method"
 
 module Rigor
@@ -65,8 +67,29 @@ module Rigor
         { "entries" => entries.map(&:to_h), "class_names" => class_names }
       end
 
+      # What a dispatch can read from the index, digested (nil for the empty index): each key's rows in their
+      # first-wins order, with the return type and the Tier B `origin_module` the dispatcher promotes through,
+      # and the synthesised class names. The rest of the provenance (the call site's path and line) is left
+      # out, so an edit that only moves the `devise` line keeps the digest. `IncrementalSession` compares it
+      # across runs (PR #2286 review M1): the index is built from class-body calls that no declaration
+      # signature records, so a recheck that sees it move cannot trust its served files.
+      def surface_digest
+        return nil if empty?
+
+        rows = entries.each_with_index
+                      .sort_by { |entry, index| [entry.kind.to_s, entry.class_name, entry.method_name.to_s, index] }
+                      .map { |entry, _| surface_row(entry) }
+        Digest::SHA256.hexdigest((rows + class_names.sort.map { |name| "class\x1f#{name}" }).join("\x00"))
+      end
+
       EMPTY_ROW = [].freeze
 
+      def surface_row(entry)
+        [entry.kind, entry.class_name, entry.method_name, entry.return_type,
+         entry.provenance[:origin_module], entry.provenance[:plugin_id]].join("\x1f")
+      end
+      private :surface_row
+
       def bucket(entries, kind)
         h = {}
         entries.each do |entry|

data/lib/rigor/inference/synthetic_method_scanner/project_members.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../../source/literals"
+
+module Rigor
+  module Inference
+    module SyntheticMethodScanner
+      # The instance-method names a project class answers ahead of a module a trait registry includes into it
+      # (PR #2286 review S1). Ruby looks a method up on the class itself before any module it includes, and a
+      # module the class itself includes or prepends sits ahead of one `devise` included earlier — so where
+      # the project names a member, the Tier B entry for it would answer the call from the wrong rung:
+      #
+      #   class User < ApplicationRecord
+      #     devise :confirmable
+      #     include PasswordPolicy   # defines password_required?
+      #     def confirmed? = :yes
+      #   end
+      #
+      # `User.new.confirmed?` is `:yes` and `password_required?` is the policy's, not `bool` from the Devise
+      # module's RBS. {SyntheticMethodScanner} therefore drops a trait entry whose name this index reports.
+      #
+      # A name counts as the class's when any reopening of the class body (in any project file) writes `def`,
+      # `alias` / `alias_method`, `attr_*`, `define_method` or `delegate` for it, or when a project module the
+      # class includes or prepends (followed through that module's own `include` / `prepend`) does. The MRO
+      # order of an `include` relative to the `devise` call is NOT consulted: a module included before the
+      # call sits behind the Devise module at runtime, but the name is declined anyway. Declining is the
+      # conservative direction — the call then reaches the tiers below the synthetic one (the discovered
+      # method, the project mixin), which answer it as they did before Tier B was reachable. A mixin constant
+      # is matched to a project module by name or by `::`-suffix, again widening only what is declined.
+      class ProjectMembers
+        # The calls that name members through their literal arguments, and the suffixes each name takes.
+        SUFFIXES_BY_CALL = Ractor.make_shareable(
+          {
+            attr_reader: [""], attr: [""], attr_writer: ["="], attr_accessor: ["", "="], delegate: [""]
+          }
+        )
+        NAME_ARG_CALLS = %i[define_method alias_method].freeze
+        MIXIN_CALLS = %i[include prepend].freeze
+
+        Entry = Struct.new(:names, :mixins)
+        private_constant :Entry
+
+        def initialize(asts)
+          @classes = Hash.new { |hash, key| hash[key] = Entry.new(Set.new, []) }
+          @modules = Hash.new { |hash, key| hash[key] = Entry.new(Set.new, []) }
+          asts.each_value { |ast| walk_namespaces(ast, []) unless ast.nil? }
+          @declared = {}
+        end
+
+        # True when `class_name`'s own body, or a project module it includes or prepends, names `method_name`.
+        def declares?(class_name, method_name)
+          (@declared[class_name] ||= declared_names(class_name)).include?(method_name.to_sym)
+        end
+
+        private
+
+        def declared_names(class_name)
+          entry = @classes.fetch(class_name, nil)
+          return Set.new.freeze if entry.nil?
+
+          names = entry.names.dup
+          visited = Set.new
+          queue = entry.mixins.dup
+          until queue.empty?
+            module_keys_for(queue.shift).each do |key|
+              next unless visited.add?(key)
+
+              names.merge(@modules[key].names)
+              queue.concat(@modules[key].mixins)
+            end
+          end
+          names.freeze
+        end
+
+        def module_keys_for(name)
+          @modules.keys.select { |key| key == name || key.end_with?("::#{name}") }
+        end
+
+        def walk_namespaces(node, scope_stack)
+          case node
+          when Prism::ClassNode, Prism::ModuleNode
+            name = SyntheticMethodScanner.class_name_from(node, scope_stack)
+            if name
+              table = node.is_a?(Prism::ClassNode) ? @classes : @modules
+              collect_members(node.body, table[name])
+            end
+            inner = scope_stack + [node]
+            node.body&.rigor_each_child { |child| walk_namespaces(child, inner) }
+          else
+            node.rigor_each_child { |child| walk_namespaces(child, scope_stack) }
+          end
+        end
+
+        # Every member-naming form under the namespace body, at any depth short of a nested namespace (a
+        # `private def`, a `def` under a conditional and an `included do ... def` all count). A nested `class`,
+        # `module` or `class << self` is another namespace's body.
+        def collect_members(node, entry)
+          return if node.nil?
+
+          case node
+          when Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode then return
+          when Prism::DefNode then entry.names << node.name if node.receiver.nil?
+          when Prism::AliasMethodNode then add_symbol(entry, node.new_name)
+          when Prism::CallNode then collect_call(node, entry)
+          end
+          node.rigor_each_child { |child| collect_members(child, entry) }
+        end
+
+        def collect_call(call, entry)
+          return unless call.receiver.nil? || call.receiver.is_a?(Prism::SelfNode)
+
+          args = call.arguments&.arguments || []
+          if MIXIN_CALLS.include?(call.name)
+            entry.mixins.concat(args.filter_map { |arg| SyntheticMethodScanner.const_name_string(arg) })
+          elsif NAME_ARG_CALLS.include?(call.name)
+            add_symbol(entry, args.first)
+          elsif (suffixes = SUFFIXES_BY_CALL[call.name])
+            args.each { |arg| suffixes.each { |suffix| add_symbol(entry, arg, suffix: suffix) } }
+          end
+        end
+
+        def add_symbol(entry, node, suffix: "")
+          value = Source::Literals.symbol_or_string_name(node)
+          entry.names << :"#{value}#{suffix}" unless value.nil?
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/synthetic_method_scanner.rb

@@ -8,6 +8,7 @@ require_relative "../source/literals"
 require_relative "../source/node_children"
 require_relative "synthetic_method"
 require_relative "synthetic_method_index"
+require_relative "synthetic_method_scanner/project_members"
 
 module Rigor
   module Inference
@@ -64,17 +65,30 @@ module Rigor
         nested_templates = collect_nested_class_templates(plugin_registry)
         return SyntheticMethodIndex::EMPTY if templates.empty? && registries.empty? && nested_templates.empty?
         # Tier B alone cannot emit without an environment: every trait entry — the direct route and the
-        # concern-re-targeted one — funnels through `module_instance_method_names`, whose first line
-        # answers `[]` for a nil environment. The production pre-pass passes `environment: nil` (#476),
-        # so a project whose only contributing plugin registers trait registries (rigor-devise on a
-        # Rails app) would otherwise pay a whole-project parse to build a provably empty index. This
-        # gate mirrors that nil guard and MUST be removed in the change that threads a real environment.
+        # concern-re-targeted one — funnels through `module_instance_method_names`, whose first line answers `[]`
+        # for a nil environment. The production pre-pass hands Tier B a (lazy) environment since #476, so this
+        # gate now guards the direct callers that pass none (a spec, a probe): a registry-only scan with
+        # no environment would otherwise pay a whole-project parse to build a provably empty index. It mirrors
+        # that nil guard and goes with it.
         return SyntheticMethodIndex::EMPTY if environment.nil? && templates.empty? && nested_templates.empty?
 
-        asts = parse_paths(paths, buffer: buffer)
+        sources = read_sources(paths, buffer: buffer)
+        # With only trait registries contributing, a project that never writes a registry's method name (no
+        # `devise` anywhere) cannot produce an entry: a call node named `devise` needs the text `devise` in its
+        # file. Skip the parse (the dominant cost) then, and the environment build it would have asked for.
+        return SyntheticMethodIndex::EMPTY if templates.empty? && nested_templates.empty? &&
+                                              none_mention_registry_method?(sources, registries)
+
+        asts = parse_sources(sources)
+        entries, class_names = collect_all_entries(asts, templates, registries, nested_templates, environment,
+                                                   fact_store)
+        SyntheticMethodIndex.new(entries: decline_project_declared(entries, asts), class_names: class_names)
+      end
+
+      # The match + emit walk over every parsed file: `[entries, class_names]`.
+      def collect_all_entries(asts, templates, registries, nested_templates, environment, fact_store)
         hierarchy = build_hierarchy(asts)
         concern_index = build_concern_index(asts)
-
         entries = []
         class_names = []
         asts.each do |path, ast|
@@ -88,8 +102,19 @@ module Rigor
           end
           collect_nested_class_entries(entries, class_names, nested_templates, ast, path) unless nested_templates.empty?
         end
+        [entries, class_names]
+      end
 
-        SyntheticMethodIndex.new(entries: entries, class_names: class_names)
+      # PR #2286 review S1 — a Tier B entry whose name the class itself declares, or a project module it includes
+      # or prepends declares, is dropped: Ruby answers that call from the project's member, ahead of the module
+      # the registry included ({ProjectMembers}). Tier C entries (no `origin_module`) are left as they were.
+      def decline_project_declared(entries, asts)
+        return entries unless entries.any? { |entry| entry.provenance[:origin_module] }
+
+        members = ProjectMembers.new(asts)
+        entries.reject do |entry|
+          entry.provenance[:origin_module] && members.declares?(entry.class_name, entry.method_name)
+        end
       end
 
       # Aggregates `(plugin_id, template)` pairs across every plugin's `manifest.heredoc_templates` in registration
@@ -249,16 +274,32 @@ module Rigor
         call_node.arguments&.arguments&.first
       end
 
-      def parse_paths(paths, buffer: nil)
+      # `path => source text` (nil when the file cannot be read), reading an editor buffer's in-flight bytes
+      # for the logical path it is bound to.
+      def read_sources(paths, buffer: nil)
         paths.to_h do |path|
           physical = buffer ? buffer.resolve(path) : path
-          source = File.read(physical)
-          [path, Prism.parse(source, filepath: path).value]
+          [path, File.read(physical)]
         rescue StandardError
           [path, nil]
         end
       end
 
+      def parse_sources(sources)
+        sources.to_h do |path, source|
+          [path, source.nil? ? nil : Prism.parse(source, filepath: path).value]
+        rescue StandardError
+          [path, nil]
+        end
+      end
+
+      def none_mention_registry_method?(sources, registries)
+        names = registries.map { |(_plugin_id, registry)| registry.method_name.to_s }
+        sources.each_value.none? do |source|
+          !source.nil? && names.any? { |name| source.include?(name) }
+        end
+      end
+
       # ADR-16 slice 4 — Concern re-targeting index.
       #
       # Walks every top-level / nested `module M` decl looking for the ActiveSupport::Concern shape:
@@ -534,6 +575,18 @@ module Rigor
       # Returns the Symbol method-name list defined on `module_name`'s RBS instance definition. Empty Array when the
       # module is not in the RBS env (silent skip — the synthetic emit produces nothing rather than fabricating method
       # names).
+      #
+      # RBS builds a module's instance definition over its self types, or over `Object` when it declares none:
+      # `Kernel#puts`, `Object#hash`, the pretty-printer's mixin — and, for `module Devise::Models::X :
+      # ActiveRecord::Base`, every `ActiveRecord::Base` method (`save`, `update`) — appear in its method table
+      # beside its own members. They are not what including the module adds, and synthesising them would answer
+      # the class's own or inherited methods from the module's view of them. A method is kept only when its
+      # defining owner is the module itself or one of the module's own ancestors (its `include` / `prepend`
+      # chain, which `definition.ancestors` lists without the self types or `Object`).
+      #
+      # A non-public method is skipped: the tier answers a call by name, and a private module method answered
+      # for `user.secret` would silence the call Ruby rejects. A definition that carries no owner (the specs'
+      # stubs) keeps every name.
       def module_instance_method_names(module_name, environment)
         return [] if environment.nil?
 
@@ -543,7 +596,14 @@ module Rigor
         definition = loader.instance_definition(module_name)
         return [] if definition.nil?
 
-        definition.methods.keys
+        own_ancestors = nil
+        definition.methods.filter_map do |name, method|
+          next name unless method.respond_to?(:defined_in)
+          next unless method.public?
+
+          own_ancestors ||= definition.ancestors.ancestors.to_set { |ancestor| ancestor.name.to_s }
+          name if own_ancestors.include?(method.defined_in.to_s)
+        end
       rescue StandardError
         []
       end

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/language_server/buffer_table.rb

@@ -98,6 +98,12 @@ module Rigor
         @dirty.key?(uri)
       end
 
+      # @return true when `uri` is open, its bytes are the ones on disk, and the table holds them faithfully: the
+      #   buffers a whole-project round analysed as they are.
+      def on_disk?(uri)
+        open?(uri) && !dirty?(uri) && !desynchronized?(uri)
+      end
+
       def [](uri)
         @entries[uri]
       end

data/lib/rigor/language_server/diagnostic_publisher.rb

@@ -100,7 +100,8 @@ module Rigor
         publish_batch(eligible)
       end
 
-      # Runs one whole-project save round and publishes to the publish set (#246). Called from `didSave`.
+      # Runs one whole-project save round and publishes to the publish set (#246), then re-publishes each dirty buffer
+      # from its own bytes (ADR-124). Called from `didSave`.
       #
       # Analysis scope is the whole project; the PUBLISH SET is the open buffers that are not dirty, plus the
       # buffer that was just saved. A dirty buffer is excluded because only its own `didChange` analysis has
@@ -117,6 +118,12 @@ module Rigor
         end
       end
 
+      # Re-publishes every open buffer from its own bytes, each through {#publish_for}. Called after the project
+      # context is invalidated (a watched file or the configuration changed): every marker on screen was computed
+      # against the world that is gone, and since ADR-124 a buffer's markers read other files' declarations, so
+      # they can move without the buffer itself changing.
+      def republish_open = @buffer_table.uris.each { |uri| publish_for(uri) }
+
       # Publishes an EMPTY diagnostic array for `uri`. The LSP-spec idiom for "clear inline markers" — called
       # from `didClose` so clients drop stale highlights when the user closes a buffer.
       def publish_empty(uri)
@@ -187,16 +194,20 @@ module Rigor
 
           notify(uri, (by_path[path] || []).filter_map { |diagnostic| to_lsp_diagnostic(diagnostic, path) })
         end
+        republish_dirty
       end
 
+      # The dirty buffers the round may not speak for, re-published from their own bytes (ADR-124). The save that
+      # started the round may have moved a declaration a dirty buffer's markers read across files, and nothing
+      # else re-analyses that buffer until its next change or save. Each goes through {#publish_for}, so the
+      # debouncer and `PublishBatcher` order it against the buffer's own `didChange` publishes: a re-publish run
+      # here, beside them, could land its older bytes' markers after a newer edit's.
+      def republish_dirty = @buffer_table.uris.each { |uri| publish_for(uri) if @buffer_table.dirty?(uri) }
+
       # The URIs this round may speak for: every open buffer whose bytes are the ones on disk. The just-saved
       # URI qualifies by definition (the client wrote it), and is named explicitly so a client that sends
       # `didSave` without a preceding applied `didChange` still refreshes it.
-      def publish_set(saved_uri)
-        ([saved_uri] + @buffer_table.uris).uniq.select do |uri|
-          @buffer_table.open?(uri) && !@buffer_table.dirty?(uri) && !@buffer_table.desynchronized?(uri)
-        end
-      end
+      def publish_set(saved_uri) = ([saved_uri] + @buffer_table.uris).uniq.select { |uri| @buffer_table.on_disk?(uri) }
 
       def run_and_notify(uri, path)
         entry = @buffer_table[uri]
@@ -239,11 +250,13 @@ module Rigor
       def publish_batch(jobs)
         with_tempfiles(jobs) do |bound_jobs|
           bindings = bound_jobs.map { |job| job.fetch(:binding) }
+          @project_context.prepare_discovery_seed
           dispatcher = Analysis::Runner::BufferPoolDispatcher.new(
             configuration: @project_context.configuration,
             cache_store: @project_context.cache_store,
             environment: @project_context.environment,
             prebuilt: @project_context.project_scan,
+            discovery_seed_for: @project_context.method(:discovery_seed_for),
             workers: worker_count
           )
           diagnostics_per_binding = dispatcher.analyze(bindings)
@@ -282,6 +295,7 @@ module Rigor
             collect_stats: false,
             buffer: binding,
             prebuilt: @project_context.project_scan,
+            discovery_seed: @project_context.discovery_seed_for(binding),
             environment: @project_context.environment
           )
           result = runner.run([path])

data/lib/rigor/language_server/project_context.rb

@@ -7,6 +7,8 @@ require_relative "../analysis/runner"
 require_relative "../analysis/incremental_session"
 require_relative "../cache/incremental_snapshot"
 require_relative "../effects/identity"
+require_relative "../analysis/path_expansion"
+require_relative "../protection/discovery_seed"
 
 module Rigor
   module LanguageServer
@@ -58,6 +60,7 @@ module Rigor
         @primed_key = nil
         @buffer_sources = {}
         @disk_feature_files = nil
+        @disk_sig_names = nil
         @environment_features = nil
         @generation = 0
         @environment = nil
@@ -112,6 +115,31 @@ module Rigor
         @project_scan ||= build_project_scan
       end
 
+      # Issue #2147 — the cross-file discovery tables a per-buffer publish seeds its `Runner` with
+      # (`discovery_seed:`, #260). A `prebuilt:` runner runs no discovery pass of its own, so without them every
+      # class another file declares reads as an external ancestor and a publish answers differently from
+      # `rigor check` over the same tree. The per-file bundles are walked once per generation; each publish
+      # re-folds them with `buffer`'s file re-walked from the buffer's bytes
+      # ({Protection::DiscoverySeed.tables_for_buffer}), so the buffer's own declarations win over its on-disk
+      # ones, and a file whose bytes on disk moved since the bundles were built is re-walked too (its digest no
+      # longer matches).
+      #
+      # The buffer's file is matched by its real path and handed to the fold under the buffer's own spelling: the
+      # binding substitutes bytes only for a path spelled exactly as its logical path (the URI's absolute path),
+      # while the configured paths may be relative (`lib`, the default) or reach the file through a symlink.
+      def discovery_seed_for(buffer)
+        Protection::DiscoverySeed.tables_for_buffer(paths: discovery_paths_for(buffer), bundles: discovery_bundles,
+                                                    buffer: buffer, constant_sources: true)
+      end
+
+      # Builds what {#discovery_seed_for} reads once per generation, so a fork batch's children inherit it instead
+      # of each walking the project.
+      def prepare_discovery_seed
+        discovery_bundles
+        discovery_real_paths
+        nil
+      end
+
       # Whole-project diagnostics for one save round (#246). The first call primes an in-process
       # {Analysis::IncrementalSession} — seeded from the on-disk snapshot a terminal
       # `rigor check --incremental` may have left, and otherwise from a full baseline; every later call is a
@@ -168,9 +196,14 @@ module Rigor
       # file.
       def required_features
         disk = (@disk_feature_files ||= Environment::RequiredFeatures.feature_files(@configuration))
-        found = disk.reject { |path, _| @buffer_sources.key?(path) }.values.flatten
-        found += @buffer_sources.values.flat_map { |source| Environment::RequiredFeatures.features_of(source) }
-        found.uniq.sort.freeze
+        scanned = disk.reject { |path, _| @buffer_sources.key?(path) }.values
+        scanned += @buffer_sources.values.map { |source| Environment::RequiredFeatures.scan_source(source) }
+        features = scanned.flat_map(&:first).uniq
+        names = scanned.flat_map(&:last).to_set
+        names.merge(@disk_sig_names ||= Environment::RequiredFeatures.sig_names(
+          Environment::RequiredFeatures.configured_sig_paths(@configuration)
+        ))
+        Environment::RequiredFeatures.relevant(features, names).sort.freeze
       end
 
       # Drops every cached collaborator and bumps the generation. The next reader rebuilds from scratch.
@@ -188,7 +221,11 @@ module Rigor
         @environment = nil
         @environment_features = nil
         @disk_feature_files = nil
+        @disk_sig_names = nil
         @project_scan = nil
+        @discovery_paths = nil
+        @discovery_real_paths = nil
+        @discovery_bundles = nil
         # The session's per-file cache was computed against the old environment / project scan, so it cannot
         # outlive them. The next save round primes a fresh one.
         @incremental_session = nil
@@ -230,6 +267,25 @@ module Rigor
         )
       end
 
+      # The configured project files, expanded as `rigor check` expands its configured paths.
+      def discovery_paths
+        @discovery_paths ||= Analysis::PathExpansion.configured_files(@configuration).freeze
+      end
+
+      # Every entry that reaches the buffer's file is respelled, so a file configured under two roots (`lib` and a
+      # symlink to it) is not folded from disk through the second.
+      def discovery_paths_for(buffer)
+        Protection::DiscoverySeed.respell_for_buffer(discovery_paths, buffer, real_paths: discovery_real_paths)
+      end
+
+      def discovery_real_paths
+        @discovery_real_paths ||= discovery_paths.map { |path| Rigor::Analysis::BufferBinding.real_path(path) }.freeze
+      end
+
+      def discovery_bundles
+        @discovery_bundles ||= Protection::DiscoverySeed.bundles(paths: discovery_paths)
+      end
+
       def build_project_scan
         runner = Analysis::Runner.new(
           configuration: @configuration,

data/lib/rigor/language_server/server.rb

@@ -282,11 +282,12 @@ module Rigor
       end
 
       # workspace/didChangeWatchedFiles NOTIFICATION. Invalidates the ProjectContext so cached pre-pass /
-      # Environment is rebuilt on the next request. Slice 7's floor: any watched file change triggers a full
-      # context rebuild. Per-file surgical invalidation (per design doc § "Project context refresh") is a
-      # follow-up; this is the LSP-correct floor.
+      # Environment is rebuilt on the next request, and re-publishes the open buffers against the new world
+      # (ADR-124). Slice 7's floor: any watched file change triggers a full context rebuild. Per-file surgical
+      # invalidation (per design doc § "Project context refresh") is a follow-up; this is the LSP-correct floor.
       def handle_did_change_watched_files(_params)
         @project_context&.invalidate!
+        @publisher&.republish_open
         nil
       end
 
@@ -295,6 +296,7 @@ module Rigor
       # (.rigor.yml / Gemfile.lock / etc).
       def handle_did_change_configuration(_params)
         @project_context&.invalidate!
+        @publisher&.republish_open
         nil
       end
 

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.