rigortype 0.4.5 → 0.4.7

data/lib/rigor/language_server/completion_provider.rb

@@ -42,7 +42,7 @@ module Rigor
         @project_context = project_context
       end
 
-      # @return LSP `CompletionItem[]` or nil
+      # @return LSP completion items, or nil
       #   when the cursor isn't at a position the provider can
       #   enumerate completions for. Returning nil maps to
       #   `result: null` per the LSP spec — clients treat it as
@@ -65,19 +65,20 @@ module Rigor
                            line: locate_at[0] + 1, character: locate_at[1] + 1)
         return nil if node.nil?
 
+        query = ScopeQuery.new(path: path, bytes: bytes_to_parse, index: nil)
         case node
         when Prism::CallNode
           # `hash[:|` patches to `hash[:KEY_SENTINEL]`, an index access call whose argument is the sentinel
           # symbol; NodeLocator at the sentinel returns the inner CallNode for `[]`. Hash-key completion wins
           # when the call is an index access on a HashShape carrier; otherwise fall through to method
           # completion.
-          hash_key_completion_for(node, parse_result.value, path) ||
-            method_completion_for(node, parse_result.value, path)
+          hash_key_completion_for(node, parse_result.value, query) ||
+            method_completion_for(node, parse_result.value, query)
         when Prism::SymbolNode
           # The sentinel symbol's NodeLocator hit; walk up via the AST to find the enclosing `[]` call.
-          hash_key_completion_for_symbol(node, parse_result.value, path)
+          hash_key_completion_for_symbol(node, parse_result.value, query)
         when Prism::ConstantPathNode
-          constant_path_completion_for(node, path)
+          constant_path_completion_for(node)
         end
       end
 
@@ -141,11 +142,11 @@ module Rigor
         nil
       end
 
-      def method_completion_for(call_node, root, path)
+      def method_completion_for(call_node, root, query)
         receiver_node = call_node.receiver
         return nil if receiver_node.nil? # implicit-self — slice-3 territory of completion
 
-        index = build_scope_index(root, path)
+        index = build_scope_index(root, query)
         receiver_scope = index[receiver_node]
         receiver_type = receiver_scope.type_of(receiver_node)
         method_completions(receiver_type, receiver_scope)
@@ -155,13 +156,13 @@ module Rigor
       # `[]` call AND the receiver's inferred type is a `Type::HashShape`. Returns nil for any other receiver
       # carrier so the dispatcher falls through to method completion (which still surfaces Hash's methods for
       # genuine method calls on a hash receiver).
-      def hash_key_completion_for(call_node, root, path)
+      def hash_key_completion_for(call_node, root, query)
         return nil unless call_node.name == :[]
 
         receiver_node = call_node.receiver
         return nil if receiver_node.nil?
 
-        index = build_scope_index(root, path)
+        index = build_scope_index(root, query)
         receiver_type = index[receiver_node].type_of(receiver_node)
         return nil unless receiver_type.is_a?(Type::HashShape)
 
@@ -171,11 +172,11 @@ module Rigor
       # When NodeLocator returns the sentinel SymbolNode directly (rather than the enclosing CallNode), walk
       # up the AST for the smallest `[]` call containing the symbol's location. Re-walks the root once; cheap
       # for LSP-sized buffers.
-      def hash_key_completion_for_symbol(symbol_node, root, path)
+      def hash_key_completion_for_symbol(symbol_node, root, query)
         call_node = enclosing_index_call(root, symbol_node)
         return nil if call_node.nil?
 
-        hash_key_completion_for(call_node, root, path)
+        hash_key_completion_for(call_node, root, query)
       end
 
       def enclosing_index_call(root, symbol_node)
@@ -212,11 +213,11 @@ module Rigor
       # resolves to a class / module FQN; we enumerate every known class whose name is an immediate child of
       # that parent. Top-level constants (`::Foo`) and parent-less paths are not yet supported (queued for
       # slice 6 follow-up).
-      def constant_path_completion_for(const_path_node, path)
+      def constant_path_completion_for(const_path_node)
         parent_fqn = parent_fqn_of(const_path_node)
         return nil if parent_fqn.nil?
 
-        scope = base_scope(path)
+        scope = Scope.empty(environment: @project_context.environment) # reads only the environment
         children = enumerate_constant_children(parent_fqn, scope)
         return nil if children.empty?
 
@@ -277,8 +278,14 @@ module Rigor
         }
       end
 
-      def base_scope(_path)
-        Scope.empty(environment: @project_context.environment)
+      # The (path, bytes) a scope query is seeded from: the bytes the parse saw, sentinel splice included. `index`
+      # memoises the request's scope index, so a `hash[...]` request that falls through from hash-key to method
+      # completion builds it once.
+      ScopeQuery = Struct.new(:path, :bytes, :index)
+      private_constant :ScopeQuery
+
+      def seeded_scope(query)
+        @project_context.seeded_scope_for(path: query.path, bytes: query.bytes)
       end
 
       def locate_node(source:, root:, line:, character:)
@@ -287,12 +294,11 @@ module Rigor
         nil
       end
 
-      def build_scope_index(root, _path)
-        scope = Scope.empty(environment: @project_context.environment)
-        Inference::ScopeIndexer.index(root, default_scope: scope)
+      def build_scope_index(root, query)
+        query.index ||= Inference::ScopeIndexer.index(root, default_scope: seeded_scope(query))
       end
 
-      # Returns an Array<Hash> of LSP `CompletionItem`s for every public method callable on the receiver.
+      # Returns the LSP completion items for every public method callable on the receiver.
       # Slice B3 extends the slice-B1 floor with:
       # - `Type::Refined` / `Type::Difference` — enumerate the underlying nominal (refinement narrows the
       #   value set, not the method set).
@@ -312,7 +318,7 @@ module Rigor
         end
       end
 
-      # Returns `[{Symbol => RBS::Definition::Method}, :instance | :singleton]` for the receiver. Composite
+      # Returns the receiver's method table with its dispatch kind (`:instance` or `:singleton`). Composite
       # carriers (Union / Intersection / Refined / shape carriers) reduce to instance-method enumeration; the
       # receiver-class label that lands in each CompletionItem's `detail` still comes from each method's own
       # `defs.first.implemented_in`, so the rendered prefix stays accurate per-method.

data/lib/rigor/language_server/config_warning_announcer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Rigor
+  module LanguageServer
+    # Issue #2231 — shows each {ConfigAudit} warning the editor has not seen yet as a `window/showMessage`
+    # (`MessageType.Warning`), worded as `rigor check` prints it on STDERR. {ProjectContext#unannounced_config_warnings}
+    # decides what is new, so a call after a reload that changed nothing writes nothing. Called on `initialized` and
+    # after each save round's configuration reload (`DiagnosticPublisher`).
+    class ConfigWarningAnnouncer
+      # LSP `MessageType.Warning`, the `type` of a `window/showMessage` notification.
+      MESSAGE_TYPE_WARNING = 2
+
+      def initialize(writer:, project_context:)
+        @writer = writer
+        @project_context = project_context
+      end
+
+      def announce
+        return unless @project_context.respond_to?(:unannounced_config_warnings)
+
+        @project_context.unannounced_config_warnings.each do |warning|
+          @writer.write(method: "window/showMessage",
+                        params: { type: MESSAGE_TYPE_WARNING, message: "rigor: #{warning.message}" })
+        end
+      end
+    end
+  end
+end

data/lib/rigor/language_server/diagnostic_publisher.rb

@@ -4,6 +4,7 @@ require "tempfile"
 
 require_relative "uri"
 require_relative "publish_batcher"
+require_relative "config_warning_announcer"
 require_relative "../analysis/runner"
 require_relative "../analysis/buffer_binding"
 
@@ -19,7 +20,7 @@ module Rigor
     # buffers' debounce timers elapse around the same moment, the `PublishBatcher` coalesces them into one
     # `#publish_many` round dispatched across the fork-based worker pool (issue #142) instead of N
     # independent, GVL-serialized `Runner` calls.
-    class DiagnosticPublisher
+    class DiagnosticPublisher # rubocop:disable Metrics/ClassLength
       # Maps Rigor severity symbols to LSP DiagnosticSeverity
       # integers per spec § "Diagnostic":
       #   1 = Error, 2 = Warning, 3 = Information, 4 = Hint.
@@ -51,6 +52,7 @@ module Rigor
         @project_context = project_context
         @debouncer = debouncer
         @debounce_seconds = debounce_seconds
+        @config_warning_announcer = ConfigWarningAnnouncer.new(writer: writer, project_context: project_context)
         @round_lock = Mutex.new
         @round_running = false
         @round_pending = false
@@ -100,7 +102,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,12 +120,21 @@ 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)
         notify(uri, [])
       end
 
+      # Issue #2231 — shows the configuration warnings the editor has not seen yet ({ConfigWarningAnnouncer}).
+      def announce_config_warnings = @config_warning_announcer.announce
+
       # Cancels every in-flight debounced task. Called from `Server#handle_shutdown` so pending publishes
       # don't fire against a closed STDOUT.
       def cancel_pending
@@ -160,8 +172,7 @@ module Rigor
 
       # True when a save arrived mid-round and the loop should run once more. Releases ownership otherwise.
       # `next`, not `break`: inside `Mutex#synchronize`'s block, `break` returns from the SYNCHRONIZE call, so
-      # a `break` written here would leave the caller's `loop` spinning forever — which is exactly what it did
-      # before this was split out.
+      # a `break` here would leave the caller's `loop` spinning forever.
       def consume_pending
         @round_lock.synchronize do
           next(@round_running = false) unless @round_pending
@@ -178,6 +189,7 @@ module Rigor
       def execute_project_round(saved_uri)
         generation = @project_context.generation
         diagnostics = @project_context.project_diagnostics
+        announce_config_warnings # the round re-read the configuration; the reload stands even if the result does not
         return if generation != @project_context.generation
 
         by_path = diagnostics.group_by(&:path)
@@ -187,16 +199,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 +255,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 +300,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/document_symbol_provider.rb

@@ -30,7 +30,7 @@ module Rigor
         @project_context = project_context
       end
 
-      # @return LSP `DocumentSymbol[]` for the
+      # @return LSP document symbols for the
       #   buffer at `uri`. Returns nil when the URI isn't open or
       #   doesn't parse cleanly enough to surface symbols — LSP
       #   clients fall back to no-outline in that case.

data/lib/rigor/language_server/folding_range_provider.rb

@@ -23,8 +23,7 @@ module Rigor
         @project_context = project_context
       end
 
-      # @return LSP `FoldingRange[]` for the
-      #   buffer, or nil when the URI isn't open / parseable.
+      # @return LSP folding ranges for the buffer, or nil when the URI isn't open / parseable.
       def provide(uri)
         path, entry = buffer_for(uri)
         return nil if entry.nil?

data/lib/rigor/language_server/hover_provider.rb

@@ -44,7 +44,7 @@ module Rigor
         node = locate_node(source: entry.bytes, root: parse_result.value, line: line + 1, character: character + 1)
         return nil if node.nil?
 
-        scope = base_scope(path)
+        scope = @project_context.seeded_scope_for(path: path, bytes: entry.bytes)
         index = Inference::ScopeIndexer.index(parse_result.value, default_scope: scope)
         node_scope = index[node]
         type = node_scope.type_of(node)
@@ -59,12 +59,6 @@ module Rigor
       rescue Source::NodeLocator::OutOfRangeError
         nil
       end
-
-      def base_scope(_path)
-        # Pulls the Environment from the cached ProjectContext so each hover avoids repeating the RBS-load
-        # build.
-        Scope.empty(environment: @project_context.environment)
-      end
     end
   end
 end

data/lib/rigor/language_server/hover_renderer.rb

@@ -60,9 +60,8 @@ module Rigor
       end
 
       # Renders a `CallNode` hover when the receiver's type can be mapped to a known RBS class and the method
-      # is declared there. Returns nil for shapes the slice-A1 floor doesn't handle (implicit `self`, Union /
-      # Refined / Shape receivers — those land in slices A2-A4 and slice 7); the caller falls back to the
-      # default body.
+      # is declared there. Returns nil for shapes this renderer does not handle (implicit `self`, Union /
+      # Refined / Shape receivers); the caller falls back to the default body.
       def render_call(call_node, return_type, node_scope_lookup)
         receiver_node = call_node.receiver
         return nil if receiver_node.nil?
@@ -133,17 +132,16 @@ module Rigor
         body << "#{return_type.describe}\n"
         body << "```"
         if (doc = rbs_documentation(definition))
-          # Close the code fence first so the comment text renders as prose, then a fresh fenced block isn't
-          # necessary — plain markdown below the code reads better in clients.
+          # The fence is already closed, so the RBS comment renders as plain markdown below the code.
           body << "\n\n---\n\n#{doc}"
         end
         body
       end
 
       # Returns the concatenated text of every RBS comment attached to the method definition, or nil when no
-      # comments exist. `RBS::Definition::Method#comments` is an Array<AST::Comment> with each entry's
-      # `.string` carrying the raw text (newline-terminated `# foo` lines). Multiple comments are joined with a
-      # blank line so each upstream `# Foo bar` paragraph is preserved.
+      # comments exist. `RBS::Definition::Method#comments` is a list of `AST::Comment`s, each with its raw text
+      # in `.string` (newline-terminated `# foo` lines). Multiple comments are joined with a blank line so each
+      # upstream `# Foo bar` paragraph is preserved.
       def rbs_documentation(definition)
         comments = definition.respond_to?(:comments) ? definition.comments : nil
         return nil if comments.nil? || comments.empty?

data/lib/rigor/language_server/project_context.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "tempfile"
+
 require_relative "../environment"
 require_relative "../project_environment"
 require_relative "../cache/store"
@@ -7,6 +9,9 @@ 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"
+require_relative "../config_audit"
 
 module Rigor
   module LanguageServer
@@ -58,6 +63,7 @@ module Rigor
         @primed_key = nil
         @buffer_sources = {}
         @disk_feature_files = nil
+        @disk_sig_names = nil
         @environment_features = nil
         @generation = 0
         @environment = nil
@@ -65,6 +71,24 @@ module Rigor
         @project_scan = nil
         @incremental_session = nil
         @session_primed = false
+        @announced_config_warnings = Set.new
+        @announce_lock = Mutex.new
+      end
+
+      # Issue #2231 — the {ConfigAudit} warnings for the configuration as last loaded that the editor has not been
+      # shown yet, or an empty array. `rigor check` prints these on every run; the server is one long run, so it
+      # announces each warning once: at `initialized` for the configuration it started with, and after a later reload
+      # (every save round re-reads `.rigor.yml`) only the warnings that were not in the previous reload's set. The
+      # comparison is by message, not by order, so reordering entries announces nothing, and fixing one of two
+      # warnings does not show the other again. A warning that was fixed and then comes back is new and is shown.
+      # Called from the dispatch thread and the save round's thread alike, hence the lock.
+      def unannounced_config_warnings
+        @announce_lock.synchronize do
+          warnings = ConfigAudit.warnings(@configuration)
+          fresh = warnings.reject { |warning| @announced_config_warnings.include?(warning.message) }
+          @announced_config_warnings = warnings.to_set(&:message)
+          fresh
+        end
       end
 
       # Returns the cached `Rigor::Environment` for this session, building it on first access. The build
@@ -112,6 +136,47 @@ 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
+
+      # Issue #2282 — the base scope an editor query (hover, completion, signature help) probes with: the same
+      # cross-file discovery seed the diagnostic publisher hands its `Runner` ({#discovery_seed_for}), so a constant
+      # or method another file defines answers what `rigor check` would. The seed fold reads the buffer through a
+      # {Analysis::BufferBinding}, so `bytes` is staged in a tempfile for the call. An empty seed (no configured
+      # files, or nothing discovered) leaves the bare single-file scope every query used before.
+      def seeded_scope_for(path:, bytes:)
+        seed = Tempfile.create(["rigor-lsp-query-", ".rb"]) do |tmp|
+          # Staged as the publisher stages them; the seed's job is to withhold the stale on-disk declarations of
+          # this file, so an empty-bytes stage is not observable by design.
+          tmp.write(bytes)
+          tmp.flush
+          discovery_seed_for(Analysis::BufferBinding.new(logical_path: path, physical_path: tmp.path))
+        end
+        Protection::DiscoverySeed.seeded_scope(environment: environment, seed: seed)
+      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 +233,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 +258,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
@@ -214,7 +288,8 @@ module Rigor
       def reload_configuration
         return unless @configuration_loader
 
-        @configuration = @configuration_loader.call
+        loaded = @configuration_loader.call
+        @announce_lock.synchronize { @configuration = loaded }
       rescue StandardError
         nil
       end
@@ -230,6 +305,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/publish_batcher.rb

@@ -15,10 +15,9 @@ module Rigor
     # dropped. The same claim/consume shape `DiagnosticPublisher#run_project_round` already uses for the
     # whole-project save round (#246), generalised to an arbitrary key type and an arbitrary batch action.
     class PublishBatcher
-      # @param on_batch — `(keys) -> void`, called with the deduplicated Array of keys pending at the
-      #   start of one round. May be called more than once in a row when keys keep arriving while a round
-      #   runs.
-      # @param on_error — `(exception) -> void`, called when `on_batch` raises. A round must
+      # @param on_batch — called with the deduplicated keys pending at the start of one round. May be called
+      #   more than once in a row when keys keep arriving while a round runs.
+      # @param on_error — called with the exception when `on_batch` raises. A round must
       #   never wedge the coalescing lock for every future `#enqueue` call — ownership is always released
       #   before this fires. Whatever was mid-flight when the round raised is lost; anything enqueued by a
       #   concurrent `#enqueue` call after this round's drain but before the rescue stays pending and rides

data/lib/rigor/language_server/selection_range_provider.rb

@@ -20,10 +20,8 @@ module Rigor
         @project_context = project_context
       end
 
-      # @param positions — LSP `Position[]` — each
-      #   `{ line:, character: }` 0-based.
-      # @return one `SelectionRange` per
-      #   position, or nil when the URI / buffer isn't resolvable.
+      # @param positions — LSP positions, each `{ line:, character: }` 0-based.
+      # @return one `SelectionRange` per position, or nil when the URI / buffer isn't resolvable.
       def provide(uri, positions)
         path, entry = buffer_for(uri)
         return nil if entry.nil?

data/lib/rigor/language_server/server.rb

@@ -194,7 +194,12 @@ module Rigor
 
       # `initialized` is a notification — no response body. Nothing is registered here yet: the server handles
       # `workspace/didChangeWatchedFiles` when a client sends it, but does not register for it dynamically.
+      #
+      # Issue #2231 — the configuration the server started with is audited here, the first point at which the
+      # client is listening, so a `.rigor.yml` key that does nothing is named in the editor as `rigor check`
+      # names it on STDERR.
       def handle_initialized
+        @publisher&.announce_config_warnings
         nil
       end
 
@@ -267,8 +272,7 @@ module Rigor
 
       # textDocument/hover REQUEST. Slice 5 returns either a `Hover` payload (markdown contents wrapping type
       # + erased-RBS info) or nil when no expression is at the queried position. Nil maps to `result: null`
-      # per LSP spec; clients suppress the popup. Returns `MethodNotFound` when no hover_provider is wired
-      # (slice 1-4 behaviour).
+      # per LSP spec; clients suppress the popup. Returns `MethodNotFound` when no hover_provider is wired.
       def handle_hover(params)
         return method_not_found("textDocument/hover") unless @hover_provider
 
@@ -282,11 +286,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 +300,7 @@ module Rigor
       # (.rigor.yml / Gemfile.lock / etc).
       def handle_did_change_configuration(_params)
         @project_context&.invalidate!
+        @publisher&.republish_open
         nil
       end
 
@@ -349,7 +355,7 @@ module Rigor
         )
       end
 
-      # textDocument/documentSymbol REQUEST. Returns the `DocumentSymbol[]` outline for the buffer at the
+      # textDocument/documentSymbol REQUEST. Returns the document-symbol outline for the buffer at the
       # requested URI. Returns `MethodNotFound` when no provider is wired.
       def handle_document_symbol(params)
         return method_not_found("textDocument/documentSymbol") unless @document_symbol_provider

data/lib/rigor/language_server/signature_help_provider.rb

@@ -25,7 +25,7 @@ module Rigor
     # parses the buffer, locates the enclosing `CallNode`, infers the receiver's type, and returns the
     # method's first overload as a `SignatureInformation`.
     #
-    # Slice C1 (this commit) ships:
+    # Slice C1 ships:
     # - Sentinel patching for `obj.foo(|` so Prism's parse succeeds (mirrors `CompletionProvider`'s slice B4
     #   pattern).
     # - First-overload signature only.
@@ -111,7 +111,7 @@ module Rigor
       end
 
       def build_signature(call_node, root, path, bytes, line, character)
-        scope_index = build_scope_index(root, path)
+        scope_index = build_scope_index(root, path, bytes)
         receiver_node = call_node.receiver
         return nil if receiver_node.nil?
 
@@ -197,8 +197,8 @@ module Rigor
         end
       end
 
-      def build_scope_index(root, _path)
-        scope = Scope.empty(environment: @project_context.environment)
+      def build_scope_index(root, path, bytes)
+        scope = @project_context.seeded_scope_for(path: path, bytes: bytes)
         Inference::ScopeIndexer.index(root, default_scope: scope)
       end
 

data/lib/rigor/lens/plugins.rb

@@ -29,7 +29,7 @@ module Rigor
         return Rigor::VERSION if absolute.start_with?("#{BUNDLED_PLUGINS}/")
 
         spec = Gem.loaded_specs.each_value.find do |gem|
-          absolute.start_with?("#{gem.full_gem_path}/") # rigor:disable undefined-method
+          absolute.start_with?("#{gem.full_gem_path}/")
         end
         spec&.version&.to_s
       rescue StandardError