rigortype 0.4.6 → 0.4.7

data/lib/rigor/inference/struct_fold_safety.rb

@@ -56,8 +56,7 @@ module Rigor
       end
 
       # @param root — the local-variable scope to scan.
-      # @param layout_lookup — a `String -> Array[Symbol] | nil` resolver mapping a constant receiver name to its
-      #   struct member list.
+      # @param layout_lookup — a resolver mapping a constant receiver name to its struct member list.
       # @return the fold-safe local names.
       def fold_safe_locals(root, layout_lookup)
         return EMPTY if root.nil?
@@ -283,8 +282,7 @@ module Rigor
       # `[1].each { s.x = v }; s.x` would read the construction value — verified unsound on #525.
       #
       # `for` shares the enclosing locals rather than opening a scope, so the block rationale does not apply
-      # to it; it is a boundary for the same reason `while` is (below), and this comment previously gave the
-      # wrong reason for it.
+      # to it; it is a boundary for the same reason `while` is (below).
       #
       # `while` / `until` are boundaries because a single static pass cannot model a member setter across
       # ITERATIONS. Issue #597 tried to lift this: `eval_loop` does join the body's exit scope with the
@@ -327,8 +325,8 @@ module Rigor
         return nil unless meta_constant?(call_node.receiver, :Struct)
 
         args = call_node.arguments&.arguments || []
-        # `[0..-2]` cannot return nil for a start of 0, but `Array#[](Range) -> Array[T]?` says it can;
-        # the `|| []` keeps the read well-typed on that worst case.
+        # `[0..-2]` cannot return nil for a start of 0, but the RBS signature of `Array#[]` with a Range says it
+        # can; the `|| []` keeps the read well-typed on that worst case.
         positional = args.last.is_a?(Prism::KeywordHashNode) ? (args[0..-2] || []) : args
         positional = positional[1..] if positional.first.is_a?(Prism::StringNode)
         return nil if positional.nil? || positional.empty?

data/lib/rigor/inference/synthetic_method_scanner.rb

@@ -64,11 +64,10 @@ module Rigor
         registries = collect_trait_registries(plugin_registry)
         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 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
+        # Tier B alone cannot emit without an environment: every trait entry funnels through
+        # `module_instance_method_names`, which answers `[]` for a nil environment. The production pre-pass always
+        # passes one (#476), so this gate guards the direct callers that pass none (a spec, a probe): a
+        # registry-only scan 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?
 
@@ -534,7 +533,7 @@ module Rigor
       #   (resolved through `registry.modules_by_symbol`; unknown
       #   symbols silently skipped per design decision (2)).
       #
-      # Returns an Array<String> of module names in `always_included` order followed by argument order.
+      # Returns the module names: the `always_included` ones first, then those for the symbol arguments in order.
       def resolve_trait_modules(registry, call_node)
         modules = registry.always_included.dup
         positional_symbols(call_node, registry).each do |symbol|

data/lib/rigor/inference/toplevel_def_census.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "../run_scoped_slots"
+require_relative "memo_audit"
+
+module Rigor
+  module Inference
+    # Issue #2515 — whether the `<toplevel>` def table's answer for a name IS the method a receiverless call of that
+    # name runs, so the callee mutation floor may read the def as written. {.reliable?} is false (the floor reads every
+    # argument as written, `StatementEvaluator::FLOOR_EVERY`) when any of these holds for `name`:
+    #
+    # - {Scope#toplevel_def_ambiguity} names a reason (the slot is contested, several ownerless definition rows of the
+    #   name exist, a `def self.name` defines it on `main`, an `alias` introduces it, an anonymous class body defines
+    #   it, `Object` defines it or has a module prepended);
+    # - a `pre_eval:` patch defines `name` on `Object`, `Kernel` or `BasicObject`.
+    #
+    # A visibility toggle (`private :name`, `public :name`) does not change which def answers a receiverless call, and
+    # `method_missing` on `Object` only answers a name nothing defines, so neither is a hazard.
+    #
+    # The answer is a function of the discovery index and the name (the environment is the run's), so it is memoised
+    # per index. A recorder is told the `defines:<name>` name edge on every call, hit or not
+    # ({Scope#toplevel_def_ambiguity}), so a file that starts or stops defining the name re-checks the caller; the memo
+    # is bypassed while one is active, as the callee floor's other memos are.
+    module ToplevelDefCensus
+      OBJECT_OWNERS = %w[Object Kernel BasicObject].freeze
+      RELIABLE_KEY = RunScopedSlots.register(:rigor_toplevel_def_reliable)
+      private_constant :OBJECT_OWNERS, :RELIABLE_KEY
+
+      module_function
+
+      # True when the `<toplevel>` table's def for `name` is the method a receiverless call of `name` runs.
+      def reliable?(scope, name)
+        return compute?(scope, name) if Analysis::DependencyRecorder.active? || MemoAudit.suspended?
+
+        table = (Thread.current[RELIABLE_KEY] ||= ObjectSpace::WeakKeyMap.new)
+        by_name = (table[scope.discovery] ||= {})
+        return by_name[name] = compute?(scope, name) unless by_name.key?(name)
+
+        MemoAudit.check("top-level def census", by_name[name], name) { compute?(scope, name) }
+      end
+
+      def compute?(scope, name)
+        return false unless scope.toplevel_def_ambiguity(name).nil?
+
+        !patched?(scope, name)
+      end
+
+      # True when a `pre_eval:` patch defines `name` on an `Object`-level class.
+      def patched?(scope, name)
+        patched = scope.environment&.project_patched_methods
+        return false if patched.nil?
+
+        patched.by_key.each_key.any? do |(owner, method_name, _kind)|
+          method_name == name && OBJECT_OWNERS.include?(owner)
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/unknown_store_widening.rb

@@ -29,9 +29,10 @@ module Rigor
     # written in; a refinement seed (`non-empty-array[0]`) still can, since its remover does not close a literal.
     #
     # A site whose widening declines leaves the binding as it is, exactly as the straight-line seam does: a
-    # precise nominal (a declared or inferred `Array[String]` is a claim this seam may not grow), a receiver
-    # that is no carrier, or a name the mutator tables do not list for that carrier (`store` on a `Tuple`, a method
-    # its class does not define). The caller MUST therefore not read an unchanged binding as describing later
+    # precise nominal under a site that stores nothing it can see (a declared or inferred `Array[String]` is a claim
+    # this seam may not grow; an element rewriter such as `map!` replaces it with the gradual arm, issue #2427), a
+    # receiver that is no carrier, or a name the mutator tables do not list for that carrier (`store` on a `Tuple`, a
+    # method its class does not define). The caller MUST therefore not read an unchanged binding as describing later
     # iterations. An empty-witness refinement under a storing mutator that keeps the witness is not such a decline:
     # the straight-line widening grows it (issue #936), and gives a site whose arguments describe nothing it stores
     # (`non-empty-array[String]` under `map!`) the gradual arm itself ({RewriteMutation}),
@@ -64,10 +65,11 @@ module Rigor
       CalleeStore = Data.define(:call, :arguments)
 
       COLLECTION_CLASSES = %w[Array Hash].freeze
+      CONTAINER_CLASSES = %w[Array Hash Set].freeze
       FLOORED_CLASSES = %w[Array Hash String].freeze
 
       NO_ARG_NODES = [].freeze
-      private_constant :COLLECTION_CLASSES, :FLOORED_CLASSES, :NO_ARG_NODES
+      private_constant :COLLECTION_CLASSES, :CONTAINER_CLASSES, :FLOORED_CLASSES, :NO_ARG_NODES
 
       module_function
 
@@ -99,6 +101,103 @@ module Rigor
         VALUE_PRESERVING.include?(method_name) && !literal_carrier?(type) ? widened : gradual_content(widened)
       end
 
+      # Issue #2296 — what the caller's argument `type` can hold after a callee that mutates the parameter inside a
+      # block (`def poke(acc) = 2.times { |i| acc[i] = "x" }`). Nothing at the call says what the block stores, so
+      # each carrier takes one unknown store and keeps its element type beside the gradual arm, as a block-captured
+      # binding does ({.widen}): `[7, 9]` reads `Array[Dynamic[top] | Integer]`, `{ a: 1 }`
+      # `Hash[Dynamic[top] | Symbol, Dynamic[top] | Integer]`, `Set[1]` `Set[Dynamic[top] | Integer]`, a literal
+      # String `String`. Not {.content_floor}'s bare carrier: dropping the element type there widened
+      # `ScopeIndexer.finalize_constant_writes` to `Hash[untyped, untyped]` under sig-gen (#2295). A class-level
+      # nominal (`Hash[String, Set[String]]`) is a claim this seam may not grow, and is left alone; a value-pinned one
+      # (`Hash["a" | "b", 1]`) holds a first-store answer the unknown store falsifies, and takes the gradual arm, as a
+      # block's unknown-store binding does.
+      def callee_block_floor(type)
+        widened = widen_store(type, :[]=, unknown_arguments(2)) || type
+        widened = callee_set_floor(widened) || widened
+        dynamic_elements(value_pinned_collection?(widened) ? gradual_content(widened) : widened)
+      end
+
+      # Issue #2296 — `type` after a callee that grows the parameter through a Set-only adder (`s.add(x)`,
+      # `s.merge(xs)`): a Set carrier takes one unknown store, and anything else, a Hash under `merge` included, is
+      # returned as nil (unchanged).
+      def callee_set_floor(type)
+        widened = widen_store(type, :add, unknown_arguments(1))
+        widened && dynamic_elements(widened)
+      end
+
+      # Issue #2647 — `type` with each container element the unknown store widened (`Dynamic[top] | String`, which an
+      # element read back out fails a literal-typed parameter with, although the callee stored a value the call never
+      # shows) made a gradual `Dynamic[String]`: the floor may forget a fact, never claim the nominal class. An element
+      # that carries no `Dynamic[top]` arm (a class-level `Array[Integer]`, which the floor leaves alone) is returned as
+      # it is. Scoped to the callee floor's two entry points, so a local mutation's unknown-store widening keeps its
+      # answer.
+      def dynamic_elements(type)
+        return type unless needs_dynamic?(type)
+
+        case type
+        when Type::Union then Type::Combinator.union(*type.members.map { |member| dynamic_elements(member) })
+        when Type::Difference then Type::Combinator.difference(dynamic_elements(type.base), type.removed)
+        when Type::Nominal
+          return type unless CONTAINER_CLASSES.include?(type.class_name) && !type.type_args.empty?
+
+          Type::Combinator.nominal_of(type.class_name, type_args: type.type_args.map { |arg| dynamic_element(arg) })
+        else type
+        end
+      end
+
+      # True when {.dynamic_elements} would change `type`: a container element with a `Dynamic[top]` member and a class
+      # member (neither a literal nor `Dynamic[top]`). Reads with `any?` only, so the common unchanged type is not
+      # rebuilt.
+      def needs_dynamic?(type)
+        case type
+        when Type::Union then type.members.any? { |member| needs_dynamic?(member) }
+        when Type::Difference then needs_dynamic?(type.base)
+        when Type::Nominal
+          CONTAINER_CLASSES.include?(type.class_name) && type.type_args.any? { |arg| needs_dynamic_element?(arg) }
+        else false
+        end
+      end
+
+      def needs_dynamic_element?(arg)
+        return false unless arg.is_a?(Type::Union)
+
+        arg.members.any? { |member| gradual_top?(member) } &&
+          arg.members.any? { |member| !member.is_a?(Type::Constant) && !gradual_top?(member) }
+      end
+
+      def gradual_top?(member) = member.is_a?(Type::Dynamic) && member.static_facet.is_a?(Type::Top)
+
+      # `Dynamic[top] | A | B` as `Dynamic[A | B]` for the class members; a literal member (a value-pinned key) and any
+      # other element stay as they are.
+      def dynamic_element(arg)
+        members = arg.is_a?(Type::Union) ? arg.members : [arg]
+        gradual, known = members.partition { |member| gradual_top?(member) }
+        return arg if gradual.empty?
+
+        literals, classes = known.partition { |member| member.is_a?(Type::Constant) }
+        return arg if classes.empty?
+
+        Type::Combinator.union(*literals, Type::Combinator.dynamic(Type::Combinator.union(*classes)))
+      end
+
+      def unknown_arguments(count) = Array.new(count) { Type::Combinator.untyped }
+
+      # False only when {.callee_block_floor} and {.callee_set_floor} are sure to leave `type` as it is: a type that is
+      # no String, Array, Hash or Set carrier in any form. A cheap gate, so a call passing only such locals skips the
+      # census closures those floors read.
+      def callee_floorable?(type)
+        case type
+        when Type::Union then type.members.any? { |member| callee_floorable?(member) }
+        when Type::Tuple, Type::HashShape, Type::Difference, Type::Refined, Type::Intersection then true
+        when Type::Constant then type.value.is_a?(String) || type.value.is_a?(::Set)
+        when Type::Nominal then FLOORABLE_NOMINALS.include?(type.class_name)
+        else false
+        end
+      end
+
+      FLOORABLE_NOMINALS = %w[Array Hash Set String].freeze
+      private_constant :FLOORABLE_NOMINALS
+
       # Every `Array` / `Hash` / `String` carrier `type` can be as its bare carrier: `Array[Dynamic[top]]`,
       # `Hash[Dynamic[top], Dynamic[top]]`, `String`. A literal, a nominal (a precise one included) and a refinement
       # over one ({.carrier_class}) all floor; so `non-empty-string`, which a callee can empty, reads `String`.

data/lib/rigor/inference/unthreaded_rebinds.rb

@@ -124,9 +124,8 @@ module Rigor
 
       # How a walk position reaches the exit scope: whether a local rebind there is threaded, whether an
       # instance variable's is, whether a class variable's or global's is, the offset below which a rebind
-      # precedes a jump,
-      # whether the position binds targets only (`:multi_assign` under a multi-assign, `:capture` under any
-      # other binding construct, false otherwise), and the locals a nested block shadows.
+      # precedes a jump, whether the position binds targets only (`:multi_assign` under a multi-assign,
+      # `:capture` under any other binding construct, false otherwise), and the locals a nested block shadows.
       Position = Data.define(:local, :ivar, :other, :horizon, :binding, :shadowed)
       private_constant :Position
 

data/lib/rigor/inference/void_tail_summary.rb

@@ -5,6 +5,7 @@ require "prism"
 require_relative "void_origin"
 require_relative "../reflection"
 require_relative "../source/node_children"
+require_relative "../run_scoped_slots"
 
 module Rigor
   module Inference
@@ -62,7 +63,7 @@ module Rigor
       # graceful-degradation branch is needed. `def_node` identity is stable per run (the ADR-85
       # {DefNodeResolver} yields one node object per `(path, node_id)`), the same identity the ADR-84
       # return memo relies on.
-      MEMO_KEY = :__rigor_void_tail_summary_memo__
+      MEMO_KEY = RunScopedSlots.register(:__rigor_void_tail_summary_memo__)
       private_constant :MEMO_KEY
 
       def initialize(scope)

data/lib/rigor/language_server/buffer_table.rb

@@ -13,9 +13,9 @@ module Rigor
     # with no `range`) stays supported — it is still legal under incremental sync and is what `didOpen` and a
     # client-side resync send.
     class BufferTable
-      # @!attribute uri      [String]  the LSP DocumentUri (e.g. `file:///abs/path/lib/foo.rb`).
-      # @!attribute bytes    [String]  the current full text of the buffer.
-      # @!attribute version  [Integer] the monotonically increasing LSP version number.
+      # @!attribute uri — the LSP DocumentUri (e.g. `file:///abs/path/lib/foo.rb`).
+      # @!attribute bytes — the current full text of the buffer.
+      # @!attribute version — the monotonically increasing LSP version number.
       Entry = Data.define(:uri, :bytes, :version)
 
       def initialize

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
@@ -130,6 +132,9 @@ module Rigor
         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
@@ -167,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
@@ -185,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)

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?