rigortype 0.4.6 → 0.4.8

data/lib/rigor/inference/string_mutation.rb

@@ -80,6 +80,20 @@ module Rigor
         type.is_a?(Type::Constant) && type.value.is_a?(String)
       end
 
+      # A predicate refinement over String (`decimal-int-string`, `lowercase-string`) under a String mutator → its
+      # `String` base. Any in-place mutation can falsify the predicate (`s.clear` leaves a `decimal-int-string`
+      # empty, `s << "A"` a `lowercase-string` mixed-case), so none keeps it. `nil` for every other input.
+      def widen_refined(refined, method_name)
+        return nil unless refined?(refined)
+        return nil unless MUTATORS.include?(method_name)
+
+        refined.base
+      end
+
+      def refined?(type)
+        type.is_a?(Type::Refined) && type.base.is_a?(Type::Nominal) && type.base.class_name == "String"
+      end
+
       # Whether `method_name`, called with `arg_types` (the call's positional argument types, possibly none), can leave
       # a non-empty receiver empty, and so retract a `non-empty-string` refinement. Every mutator outside
       # {EMPTY_PRESERVING} can, except a {TRANSLATORS} call whose replacement is provably non-empty.

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?
 
@@ -324,21 +323,29 @@ module Rigor
       # - `class_methods do ... end` blocks are NOT yet handled —
       #   singleton-level emission is out of scope per the slice-3
       #   floor framing.
+      #
+      # Issue #3005 — the `included do` blocks of every body of a module some body extends with Concern are read: a
+      # reopening that does not repeat the `extend` runs its block on a module that is already a concern (loaded
+      # first, its `included do` raises, so no running program has the includer without the calls). A module no
+      # body extends with Concern contributes nothing.
       CONCERN_NAME = "ActiveSupport::Concern"
 
       def build_concern_index(asts)
-        index = {}
+        bodies = Hash.new { |hash, name| hash[name] = [] }
         asts.each_value do |ast|
           next if ast.nil?
 
           walk_module_decls(ast, []) do |module_name, body|
-            next if module_name.nil? || body.nil?
-            next unless concern_module_body?(body)
-
-            deferred_calls = collect_included_do_calls(body)
-            index[module_name] = deferred_calls.freeze if deferred_calls.any?
+            bodies[module_name] << body unless module_name.nil? || body.nil?
           end
         end
+        index = {}
+        bodies.each do |module_name, list|
+          next unless list.any? { |body| concern_module_body?(body) }
+
+          deferred_calls = list.flat_map { |body| collect_included_do_calls(body) }
+          index[module_name] = deferred_calls.freeze if deferred_calls.any?
+        end
         index.freeze
       end
 
@@ -360,18 +367,34 @@ module Rigor
       end
 
       # Recognises a module body that begins with (or contains at top level) an `extend ActiveSupport::Concern`
-      # statement.
+      # statement. Issue #3005 — `self.extend` and a receiverless or `self.` `send` / `public_send` /
+      # `__send__(:extend, …)` are the same call.
       def concern_module_body?(body)
         return false unless body.respond_to?(:body)
 
         body.body.any? do |stmt|
-          next false unless stmt.is_a?(Prism::CallNode) && stmt.receiver.nil? && stmt.name == :extend
-
-          args = stmt.arguments&.arguments || []
-          args.any? { |arg| const_name_string(arg) == CONCERN_NAME }
+          args = concern_extend_arguments(stmt)
+          args&.any? { |arg| const_name_string(arg) == CONCERN_NAME }
         end
       end
 
+      CONCERN_SEND_CALLS = %i[send public_send __send__].freeze
+      private_constant :CONCERN_SEND_CALLS
+
+      # The modules an `extend` statement on the module's own `self` names, or nil for any other statement.
+      def concern_extend_arguments(stmt)
+        return nil unless stmt.is_a?(Prism::CallNode)
+        return nil unless stmt.receiver.nil? || stmt.receiver.is_a?(Prism::SelfNode)
+
+        args = stmt.arguments&.arguments || []
+        return args if stmt.name == :extend
+        return nil unless CONCERN_SEND_CALLS.include?(stmt.name)
+
+        name = args.first
+        sent = name.unescaped if name.is_a?(Prism::SymbolNode) || name.is_a?(Prism::StringNode)
+        sent == "extend" ? args.drop(1) : nil
+      end
+
       def collect_included_do_calls(body)
         body.body.flat_map do |stmt|
           included_do = stmt.is_a?(Prism::CallNode) && stmt.receiver.nil? && stmt.name == :included
@@ -534,7 +557,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,67 @@
+# frozen_string_literal: true
+
+require_relative "../typing_state"
+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
+      # ADR-129 WD1 — a run-scoped Memo, per discovery index and name: the answer is a function of both, and
+      # `MemoAudit` checks it on a hit.
+      RELIABLE = TypingState.memo(
+        :toplevel_def_reliable,
+        run_scoped: true, audit: "top-level def census",
+        reason: "keyed by discovery index, then name; the environment is the run's; audited by MemoAudit"
+      )
+      private_constant :OBJECT_OWNERS, :RELIABLE
+
+      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 = TypingState.current.weak_key_map(RELIABLE)
+        by_name = (table[scope.discovery] ||= {})
+        unless by_name.key?(name)
+          return by_name[name] = MemoAudit.key_audit("top-level def census") { compute?(scope, name) }
+        end
+
+        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) = Type::Combinator.untyped?(member)
+
+      # `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/untyped_rejoin.rb

@@ -57,7 +57,7 @@ module Rigor
       end
 
       def candidate?(entry_type, joined_type)
-        entry_type.is_a?(Type::Dynamic) && entry_type.static_facet.is_a?(Type::Top) &&
+        Type::Combinator.untyped?(entry_type) &&
           joined_type.is_a?(Type::Union) && joined_type.members.any?(Type::Dynamic)
       end
 

data/lib/rigor/inference/void_tail_summary.rb

@@ -5,6 +5,8 @@ require "prism"
 require_relative "void_origin"
 require_relative "../reflection"
 require_relative "../source/node_children"
+require_relative "../typing_state"
+require_relative "../memo_audit"
 
 module Rigor
   module Inference
@@ -53,8 +55,8 @@ module Rigor
     # cycle (nil). Memoising is therefore always sound, and the cycle guard only ever rejects a node that
     # is still mid-computation on the current chain (never yet memoised).
     class VoidTailSummary
-      # Run-scoped memo, the ADR-84 `return_memo_bucket` house pattern: a single retained slot on
-      # `Thread.current` keyed by the run-generation token's identity, so a re-run in one process (LSP,
+      # Run-scoped memo, the ADR-84 `return_memo_bucket` house pattern: a single retained slot in
+      # the thread's {TypingState} keyed by the run-generation token's identity, so a re-run in one process (LSP,
       # ADR-62 warm loop) lands in a fresh bucket and can neither serve stale entries nor accumulate
       # them. Thread-local ⇒ each fork-pool worker (a separate process) and each Ractor-pool worker (its
       # own Ractor-local `Thread.current`) builds its own bucket; the bucket hash is created and mutated
@@ -62,8 +64,15 @@ 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__
-      private_constant :MEMO_KEY
+      #
+      # ADR-129 WD1 — a run-scoped Memo keyed on the token's identity: the bucket holds summaries that are pure
+      # functions of the def node they key on within one run.
+      MEMO = TypingState.memo(
+        :void_tail_summary,
+        run_scoped: true, audit: ["void tail origin", "void tail walk"],
+        reason: "a bucket of per-def-node summaries, keyed on the run-generation token's identity"
+      )
+      private_constant :MEMO
 
       def initialize(scope)
         @scope = scope
@@ -81,7 +90,11 @@ module Rigor
         return nil if def_node.nil?
 
         memo = memo_bucket
-        return memo[def_node] if memo.key?(def_node)
+        if memo.key?(def_node)
+          return MemoAudit.check("void tail origin", memo[def_node], def_node) do
+            walk(def_node, owner, kind, {}.compare_by_identity)
+          end
+        end
 
         walk(def_node, owner, kind, {}.compare_by_identity)
       end
@@ -97,10 +110,14 @@ module Rigor
         return nil if visited.key?(def_node)
 
         memo = memo_bucket
-        return memo[def_node] if memo.key?(def_node)
+        if memo.key?(def_node)
+          return MemoAudit.check("void tail walk", memo[def_node], def_node) do
+            walk(def_node, owner, kind, {}.compare_by_identity)
+          end
+        end
 
         visited[def_node] = true
-        memo[def_node] = compute(def_node, owner, kind, visited)
+        memo[def_node] = MemoAudit.key_audit("void tail walk") { compute(def_node, owner, kind, visited) }
       end
 
       def compute(def_node, owner, kind, visited)
@@ -205,11 +222,14 @@ module Rigor
       end
 
       def memo_bucket
+        return {}.compare_by_identity if MemoAudit.enabled? && MemoAudit.suspended?
+
         generation = scope.run_generation || scope.discovered_def_nodes
-        slot = Thread.current[MEMO_KEY]
+        state = TypingState.current
+        slot = state[MEMO]
         unless slot && slot[0].equal?(generation)
           slot = [generation, {}.compare_by_identity]
-          Thread.current[MEMO_KEY] = slot
+          state[MEMO] = slot
         end
         slot[1]
       end

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