rigortype 0.2.7 → 0.2.8

data/lib/rigor/language_server/folding_range_provider.rb

@@ -7,17 +7,13 @@ require_relative "buffer_resolution"
 
 module Rigor
   module LanguageServer
-    # Answers `textDocument/foldingRange` requests. Walks the Prism
-    # AST and emits one `FoldingRange` per foldable construct:
-    # `class` / `module` / `def` / `singleton class << self` /
-    # block (`do…end` or `{…}`). Skips single-line constructs
-    # (start_line == end_line) since there's nothing to fold.
+    # Answers `textDocument/foldingRange` requests. Walks the Prism AST and emits one `FoldingRange` per
+    # foldable construct: `class` / `module` / `def` / `singleton class << self` / block (`do…end` or `{…}`).
+    # Skips single-line constructs (start_line == end_line) since there's nothing to fold.
     #
-    # Ranges are LSP 0-based. `startLine` is the line containing
-    # the opening keyword (`class`, `def`); `endLine` is the last
-    # line OF the body — one line before the `end` keyword — so
-    # collapsed view shows the opener intact and hides the body
-    # only.
+    # Ranges are LSP 0-based. `startLine` is the line containing the opening keyword (`class`, `def`); `endLine`
+    # is the last line OF the body — one line before the `end` keyword — so collapsed view shows the opener
+    # intact and hides the body only.
     class FoldingRangeProvider
       include BufferResolution
 
@@ -34,9 +30,8 @@ module Rigor
 
         parse_result = Prism.parse(entry.bytes, filepath: path,
                                                 version: @project_context.configuration.target_ruby)
-        # Tolerate partial parse errors — fold whatever AST Prism
-        # produced. Editors prefer a stale outline / fold map
-        # over none.
+        # Tolerate partial parse errors — fold whatever AST Prism produced. Editors prefer a stale outline /
+        # fold map over none.
         ranges = []
         walk(parse_result.value, ranges)
         ranges
@@ -59,12 +54,9 @@ module Rigor
       def add_range(node, ranges)
         loc = node.location
         start_line = loc.start_line - 1
-        # `end_line` includes the line of the `end` keyword.
-        # Folding should hide the body and leave both the opener
-        # AND the `end` keyword visible — so endLine is one line
-        # before `end`. When the body is a single line, that
-        # makes start == end (one-line fold), which most editors
-        # skip; we filter those out.
+        # `end_line` includes the line of the `end` keyword. Folding should hide the body and leave both the
+        # opener AND the `end` keyword visible — so endLine is one line before `end`. When the body is a single
+        # line, that makes start == end (one-line fold), which most editors skip; we filter those out.
         end_line = loc.end_line - 2
         return if end_line <= start_line
 

data/lib/rigor/language_server/hover_provider.rb

@@ -12,16 +12,14 @@ require_relative "../inference/scope_indexer"
 
 module Rigor
   module LanguageServer
-    # Answers `textDocument/hover` requests by running the same
-    # NodeLocator + ScopeIndexer + `Scope#type_of` chain that
-    # `rigor type-of` already drives. The LSP wraps the result in a
-    # `Hover` payload with markdown contents.
+    # Answers `textDocument/hover` requests by running the same NodeLocator + ScopeIndexer + `Scope#type_of`
+    # chain that `rigor type-of` already drives. The LSP wraps the result in a `Hover` payload with markdown
+    # contents.
     #
     # Per LSP spec § "Position":
     # - `line` and `character` are 0-based.
-    # - `character` counts UTF-16 code units; v1 emits byte counts
-    #   for ASCII source (UTF-16 conversion is queued, see design
-    #   doc § "Open questions").
+    # - `character` counts UTF-16 code units; v1 emits byte counts for ASCII source (UTF-16 conversion is
+    #   queued, see design doc § "Open questions").
     class HoverProvider
       include BufferResolution
 
@@ -42,8 +40,7 @@ module Rigor
         parse_result = Prism.parse(entry.bytes, filepath: path, version: @project_context.configuration.target_ruby)
         return nil unless parse_result.errors.empty?
 
-        # Rigor's NodeLocator uses 1-based line / column; LSP uses
-        # 0-based. Translate at the boundary.
+        # Rigor's NodeLocator uses 1-based line / column; LSP uses 0-based. Translate at the boundary.
         node = locate_node(source: entry.bytes, root: parse_result.value, line: line + 1, character: character + 1)
         return nil if node.nil?
 
@@ -64,8 +61,8 @@ module Rigor
       end
 
       def base_scope(_path)
-        # Pulls the Environment from the cached ProjectContext so
-        # each hover avoids repeating the RBS-load build.
+        # Pulls the Environment from the cached ProjectContext so each hover avoids repeating the RBS-load
+        # build.
         Scope.empty(environment: @project_context.environment)
       end
     end

data/lib/rigor/language_server/hover_renderer.rb

@@ -9,18 +9,14 @@ require_relative "../type/difference"
 
 module Rigor
   module LanguageServer
-    # Builds the LSP `Hover.contents` markdown body. Dispatches on
-    # the hovered Prism node class so each shape (method call,
-    # constant, local, ivar, literal) gets the most relevant
-    # type-aware presentation per
+    # Builds the LSP `Hover.contents` markdown body. Dispatches on the hovered Prism node class so each shape
+    # (method call, constant, local, ivar, literal) gets the most relevant type-aware presentation per
     # `docs/design/20260517-lsp-hover-completion.md`.
     class HoverRenderer
-      # @param node_scope_lookup [#[]] node-to-scope table built
-      #   by `ScopeIndexer.index`. The renderer indexes into it to
-      #   retrieve the receiver's narrow scope when specialising on
-      #   `CallNode`. The lookup never returns nil (the indexer's
-      #   Hash carries `default_scope` as its default value), so
-      #   the renderer trusts the lookup result.
+      # @param node_scope_lookup [#[]] node-to-scope table built by `ScopeIndexer.index`. The renderer indexes
+      #   into it to retrieve the receiver's narrow scope when specialising on `CallNode`. The lookup never
+      #   returns nil (the indexer's Hash carries `default_scope` as its default value), so the renderer trusts
+      #   the lookup result.
       def render(node:, type:, node_scope_lookup:)
         body = render_body(node, type, node_scope_lookup)
         result = { contents: { kind: "markdown", value: body } }
@@ -30,11 +26,9 @@ module Rigor
 
       private
 
-      # Converts a Prism `Location` to an LSP `Range` (0-based
-      # line, 0-based UTF-16-character column). UTF-16 conversion
-      # is queued — slice E1 emits byte columns which match for
-      # ASCII source; non-ASCII falls back gracefully because
-      # clients clamp out-of-range columns to the end of line.
+      # Converts a Prism `Location` to an LSP `Range` (0-based line, 0-based UTF-16-character column). UTF-16
+      # conversion is queued — slice E1 emits byte columns which match for ASCII source; non-ASCII falls back
+      # gracefully because clients clamp out-of-range columns to the end of line.
       def lsp_range_for(node)
         loc = node.location
         {
@@ -65,12 +59,10 @@ module Rigor
         end
       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.
+      # 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.
       def render_call(call_node, return_type, node_scope_lookup)
         receiver_node = call_node.receiver
         return nil if receiver_node.nil?
@@ -91,11 +83,9 @@ module Rigor
         )
       end
 
-      # @return [[RBS::Definition::Method, String, Symbol], nil]
-      #   the resolved method definition, the receiver class name,
-      #   and the dispatch kind (`:instance` or `:singleton`); nil
-      #   when the receiver shape isn't yet supported or the
-      #   method doesn't resolve through the RBS env.
+      # @return [[RBS::Definition::Method, String, Symbol], nil] the resolved method definition, the receiver
+      #   class name, and the dispatch kind (`:instance` or `:singleton`); nil when the receiver shape isn't
+      #   yet supported or the method doesn't resolve through the RBS env.
       def lookup_method(receiver_type, method_name, scope)
         case receiver_type
         when Type::Singleton
@@ -114,13 +104,10 @@ module Rigor
         end
       end
 
-      # Maps a receiver carrier to the underlying RBS class name
-      # for method lookup. v1 handles the two carriers that produce
-      # well-defined ".methods to enumerate" semantics: `Nominal[C]`
-      # (the canonical case) and `Constant<v>` (literal scalars,
-      # where the value's runtime class is the receiver). Other
-      # carriers fall through to the default hover; slice 7 of the
-      # design adds Union / Refined / Shape handling.
+      # Maps a receiver carrier to the underlying RBS class name for method lookup. v1 handles the two carriers
+      # that produce well-defined ".methods to enumerate" semantics: `Nominal[C]` (the canonical case) and
+      # `Constant<v>` (literal scalars, where the value's runtime class is the receiver). Other carriers fall
+      # through to the default hover; slice 7 of the design adds Union / Refined / Shape handling.
       def nominal_class_name(type)
         case type
         when Type::Nominal then type.class_name
@@ -128,12 +115,9 @@ module Rigor
         end
       end
 
-      # `Type::Constant<value>`'s `value` is the literal Ruby
-      # object; map it to the RBS-canonical class name through
-      # `Object#class`. The cross-runtime mapping mirrors how the
-      # dispatcher already widens a literal to its nominal class
-      # at the call site — keep these in sync if a new literal
-      # carrier lands.
+      # `Type::Constant<value>`'s `value` is the literal Ruby object; map it to the RBS-canonical class name
+      # through `Object#class`. The cross-runtime mapping mirrors how the dispatcher already widens a literal
+      # to its nominal class at the call site — keep these in sync if a new literal carrier lands.
       def constant_to_class_name(value)
         value.class.name
       end
@@ -149,21 +133,17 @@ 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.
+          # 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.
           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.
+      # 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.
       def rbs_documentation(definition)
         comments = definition.respond_to?(:comments) ? definition.comments : nil
         return nil if comments.nil? || comments.empty?
@@ -172,9 +152,8 @@ module Rigor
         text.empty? ? nil : text
       end
 
-      # v1 surfaces the FIRST overload only. Multi-overload
-      # presentation is queued (design doc § "Out of scope for v2"
-      # — multi-overload signature display).
+      # v1 surfaces the FIRST overload only. Multi-overload presentation is queued (design doc § "Out of scope
+      # for v2" — multi-overload signature display).
       def first_method_type(definition)
         method_type = definition.method_types.first
         return "(unknown)" if method_type.nil?
@@ -182,11 +161,9 @@ module Rigor
         method_type.to_s
       end
 
-      # Specialises `ConstantReadNode` (`Foo`) and `ConstantPathNode`
-      # (`Foo::Bar`) when the inferred type is a `Type::Singleton`
-      # — i.e., the constant refers to a class / module. Returns nil
-      # for constants pointing at values (`FOO = 42`); those fall
-      # through to the literal-polish slice (A4).
+      # Specialises `ConstantReadNode` (`Foo`) and `ConstantPathNode` (`Foo::Bar`) when the inferred type is a
+      # `Type::Singleton` — i.e., the constant refers to a class / module. Returns nil for constants pointing
+      # at values (`FOO = 42`); those fall through to the literal-polish slice (A4).
       def render_constant(node, type, node_scope_lookup)
         return nil unless type.is_a?(Type::Singleton)
 
@@ -202,10 +179,9 @@ module Rigor
         body
       end
 
-      # Resolves the source-file location for a class FQN by reading
-      # the RBS loader's `class_decl_paths` table. Returns nil when
-      # the table doesn't carry attribution (cache-hit paths replace
-      # it with a sentinel, see `RunStats.attribution_available?`).
+      # Resolves the source-file location for a class FQN by reading the RBS loader's `class_decl_paths` table.
+      # Returns nil when the table doesn't carry attribution (cache-hit paths replace it with a sentinel, see
+      # `RunStats.attribution_available?`).
       def defined_in(fqn, scope)
         loader = scope&.environment&.rbs_loader
         return nil if loader.nil?
@@ -216,12 +192,9 @@ module Rigor
         path
       end
 
-      # Specialises local-variable reads / writes / target nodes.
-      # Surfaces the variable name + narrowed type. "Bound at"
-      # source-line attribution is queued (Scope#locals tracks
-      # {name => Type} but not the binding location); when the
-      # ScopeIndexer grows a side-table for it, slice A3 follow-up
-      # can fill the row in.
+      # Specialises local-variable reads / writes / target nodes. Surfaces the variable name + narrowed type.
+      # "Bound at" source-line attribution is queued (Scope#locals tracks {name => Type} but not the binding
+      # location); when the ScopeIndexer grows a side-table for it, slice A3 follow-up can fill the row in.
       def render_local(node, type)
         body = +"```ruby\n"
         body << "# Local\n#{node.name}\n\n"
@@ -230,11 +203,9 @@ module Rigor
         body
       end
 
-      # Specialises instance-variable reads / writes / targets.
-      # Surfaces the ivar name + narrowed type + the enclosing
-      # class context derived from the scope's `self_type`. When
-      # the self_type isn't a Nominal (e.g., top-level main) the
-      # enclosing-class row is omitted.
+      # Specialises instance-variable reads / writes / targets. Surfaces the ivar name + narrowed type + the
+      # enclosing class context derived from the scope's `self_type`. When the self_type isn't a Nominal (e.g.,
+      # top-level main) the enclosing-class row is omitted.
       def render_ivar(node, type, node_scope_lookup)
         scope = node_scope_lookup[node]
         body = +"```ruby\n"
@@ -249,20 +220,16 @@ module Rigor
 
       def enclosing_class_for(scope)
         self_type = scope.self_type
-        # Both `Nominal[C]` and `Singleton[C]` carry `class_name`;
-        # we want the class label either way. Combined branch
-        # keeps the slice-A3 contract simple.
+        # Both `Nominal[C]` and `Singleton[C]` carry `class_name`; we want the class label either way. Combined
+        # branch keeps the slice-A3 contract simple.
         self_type.class_name if self_type.is_a?(Type::Nominal) || self_type.is_a?(Type::Singleton)
       end
 
-      # Specialises literal-bearing nodes (Integer / Float / String /
-      # Symbol / Regex / true / false / nil / Array / Hash). Drops
-      # the slice-A1 `node:` debug row in favour of a cleaner
-      # `# Type` + `# Erased` framing, and surfaces the refinement
-      # / difference name when one is present. For Array / Hash
-      # the shape carriers (`Tuple<...>` / `HashShape<...>`) already
-      # describe element types, so the framing is identical to
-      # primitive literals.
+      # Specialises literal-bearing nodes (Integer / Float / String / Symbol / Regex / true / false / nil /
+      # Array / Hash). Drops the slice-A1 `node:` debug row in favour of a cleaner `# Type` + `# Erased`
+      # framing, and surfaces the refinement / difference name when one is present. For Array / Hash the shape
+      # carriers (`Tuple<...>` / `HashShape<...>`) already describe element types, so the framing is identical
+      # to primitive literals.
       def render_literal(_node, type)
         body = +"```ruby\n"
         body << "# Type\n#{type.describe}\n"
@@ -274,16 +241,12 @@ module Rigor
         body
       end
 
-      # Surfaces the canonical kebab-case refinement name when the
-      # type is a `Refined` or `Difference` carrier with a
-      # registered canonical_name (e.g. `non-empty-string` /
-      # `positive-int`). `canonical_name` is private on both
-      # carriers; the LSP layer is a trusted internal consumer
-      # and `send` is the documented escape hatch for surfacing
-      # display-level metadata. Returns nil for unrefined carriers
-      # and for refinements that don't have a canonical name (those
-      # are presented through the predicate-id operator form by
-      # `describe`).
+      # Surfaces the canonical kebab-case refinement name when the type is a `Refined` or `Difference` carrier
+      # with a registered canonical_name (e.g. `non-empty-string` / `positive-int`). `canonical_name` is
+      # private on both carriers; the LSP layer is a trusted internal consumer and `send` is the documented
+      # escape hatch for surfacing display-level metadata. Returns nil for unrefined carriers and for
+      # refinements that don't have a canonical name (those are presented through the predicate-id operator
+      # form by `describe`).
       def refinement_name_for(type)
         return nil unless type.is_a?(Type::Refined) || type.is_a?(Type::Difference)
 

data/lib/rigor/language_server/loop.rb

@@ -5,24 +5,20 @@ require "language_server-protocol"
 
 module Rigor
   module LanguageServer
-    # JSON-RPC dispatch loop. Drains messages from `reader`, routes
-    # each to `server.dispatch`, and writes responses back through
-    # `writer`. Stops when either the reader hits EOF (client closed
-    # its end of the pipe) or the server transitions to `:exited`.
+    # JSON-RPC dispatch loop. Drains messages from `reader`, routes each to `server.dispatch`, and writes
+    # responses back through `writer`. Stops when either the reader hits EOF (client closed its end of the
+    # pipe) or the server transitions to `:exited`.
     #
-    # The Loop knows the request / notification distinction from the
-    # presence of the `id` field on the inbound JSON-RPC envelope:
+    # The Loop knows the request / notification distinction from the presence of the `id` field on the inbound
+    # JSON-RPC envelope:
     #
-    # - Request (`id` present) → ALWAYS gets a response (success or
-    #   error). `Server#dispatch` returning nil for a request maps
-    #   to `result: null` per the LSP shutdown contract.
-    # - Notification (`id` absent) → NEVER gets a response. The
-    #   dispatcher's return value is discarded.
+    # - Request (`id` present) → ALWAYS gets a response (success or error). `Server#dispatch` returning nil
+    #   for a request maps to `result: null` per the LSP shutdown contract.
+    # - Notification (`id` absent) → NEVER gets a response. The dispatcher's return value is discarded.
     #
-    # JSON parse errors at the framing boundary surface as an LSP
-    # `ParseError` (-32700) response with `id: null` per JSON-RPC
-    # spec § 5.1; the loop continues so a corrupt frame doesn't
-    # poison the rest of the session.
+    # JSON parse errors at the framing boundary surface as an LSP `ParseError` (-32700) response with
+    # `id: null` per JSON-RPC spec § 5.1; the loop continues so a corrupt frame doesn't poison the rest of the
+    # session.
     class Loop
       def initialize(reader:, writer:, server:)
         @reader = reader
@@ -52,13 +48,12 @@ module Rigor
         write_response(id, result)
       end
 
-      # Maps the dispatcher's return value to a JSON-RPC response
-      # envelope. `Server#dispatch` returns one of three shapes:
+      # Maps the dispatcher's return value to a JSON-RPC response envelope. `Server#dispatch` returns one of
+      # three shapes:
       #
       # - `{ error: {...} }` — surfaced as `{ id, error: {...} }`.
       # - any other Hash — surfaced as `{ id, result: hash }`.
-      # - `nil` — surfaced as `{ id, result: null }` (the LSP
-      #   `shutdown` contract).
+      # - `nil` — surfaced as `{ id, result: null }` (the LSP `shutdown` contract).
       def write_response(id, result)
         if result.is_a?(Hash) && result.key?(:error)
           @writer.write(id: id, error: result[:error])

data/lib/rigor/language_server/project_context.rb

@@ -6,49 +6,33 @@ require_relative "../analysis/runner"
 
 module Rigor
   module LanguageServer
-    # Per-session cache of the project-wide analyzer state the LSP
-    # reads on every request — chiefly the `Environment` (with its
-    # ~100-300ms RBS env build), a read-only `Cache::Store` that
-    # lets the runner hit the on-disk RBS cache without writing
-    # back, and (since the pre-pass cache slice) a frozen
-    # {Rigor::Analysis::ProjectScan} snapshot covering the
-    # plugin registry, dependency-source index, and pre-pass
-    # scanner outputs.
+    # Per-session cache of the project-wide analyzer state the LSP reads on every request — chiefly the
+    # `Environment` (with its ~100-300ms RBS env build), a read-only `Cache::Store` that lets the runner hit
+    # the on-disk RBS cache without writing back, and (since the pre-pass cache slice) a frozen
+    # {Rigor::Analysis::ProjectScan} snapshot covering the plugin registry, dependency-source index, and
+    # pre-pass scanner outputs.
     #
-    # The pre-pass scan lets `DiagnosticPublisher#run_analysis`
-    # build a `Runner` with `prebuilt:` so per-buffer publishes
-    # skip plugin `#prepare`, the synthetic-method scanner, the
-    # project-patched scanner, and the dependency-source walker.
-    # For projects with substrate plugins / opt-in dependency
-    # source / sizeable `pre_eval:` configuration this cuts
-    # publish wall time substantially — for the trivial case
-    # the savings are small (the per-publish path is already
-    # ≈2ms once Environment is warm).
+    # The pre-pass scan lets `DiagnosticPublisher#run_analysis` build a `Runner` with `prebuilt:` so per-buffer
+    # publishes skip plugin `#prepare`, the synthetic-method scanner, the project-patched scanner, and the
+    # dependency-source walker. For projects with substrate plugins / opt-in dependency source / sizeable
+    # `pre_eval:` configuration this cuts publish wall time substantially — for the trivial case the savings
+    # are small (the per-publish path is already ≈2ms once Environment is warm).
     #
     # Invalidation:
-    # - `#invalidate!` drops the cached environment AND project
-    #   scan + bumps the generation counter; the next reader
-    #   rebuilds. Watched-file changes
-    #   (`workspace/didChangeWatchedFiles`) and configuration
-    #   refreshes (`workspace/didChangeConfiguration`) both
-    #   trigger this — the next publish observes the new
-    #   project state.
-    # - The cache store is NOT invalidated on file change — it's
-    #   content-addressed (digests over file contents), so stale
-    #   entries naturally lose their key match. We DO keep a single
-    #   Store instance across the session so the in-process memo
-    #   serves repeat reads cheaply.
+    # - `#invalidate!` drops the cached environment AND project scan + bumps the generation counter; the next
+    #   reader rebuilds. Watched-file changes (`workspace/didChangeWatchedFiles`) and configuration refreshes
+    #   (`workspace/didChangeConfiguration`) both trigger this — the next publish observes the new project
+    #   state.
+    # - The cache store is NOT invalidated on file change — it's content-addressed (digests over file
+    #   contents), so stale entries naturally lose their key match. We DO keep a single Store instance across
+    #   the session so the in-process memo serves repeat reads cheaply.
     #
-    # Editor-mode trade-off: the cached `project_scan` was built
-    # without any `buffer:` binding so scanners observed on-disk
-    # bytes for every project file (including the file the user
-    # is editing right now). Edits to a file that itself declares
-    # `Plugin::Macro::HeredocTemplate` consumers or
-    # `pre_eval:`-listed methods are not visible until a
-    # watched-file change triggers `invalidate!`. The common
-    # editor flow (save → file watch fires → publish) refreshes
-    # automatically; the rare in-flight edit to a substrate-DSL
-    # file is the documented edge case.
+    # Editor-mode trade-off: the cached `project_scan` was built without any `buffer:` binding so scanners
+    # observed on-disk bytes for every project file (including the file the user is editing right now). Edits
+    # to a file that itself declares `Plugin::Macro::HeredocTemplate` consumers or `pre_eval:`-listed methods
+    # are not visible until a watched-file change triggers `invalidate!`. The common editor flow (save → file
+    # watch fires → publish) refreshes automatically; the rare in-flight edit to a substrate-DSL file is the
+    # documented edge case.
     class ProjectContext
       attr_reader :configuration, :generation
 
@@ -60,27 +44,20 @@ module Rigor
         @project_scan = nil
       end
 
-      # Returns the cached `Rigor::Environment` for this session,
-      # building it on first access. The build includes the
-      # project's full scan state (plugin registry, dependency-source
-      # index, synthetic-method / project-patched indexes — drawn
-      # from {#project_scan}) AND every Bundler / RBS-collection
-      # axis the runner consults at build time, so the resulting
-      # env is bit-for-bit equivalent to what `Runner.run` would
-      # have built on its own.
+      # Returns the cached `Rigor::Environment` for this session, building it on first access. The build
+      # includes the project's full scan state (plugin registry, dependency-source index, synthetic-method /
+      # project-patched indexes — drawn from {#project_scan}) AND every Bundler / RBS-collection axis the
+      # runner consults at build time, so the resulting env is bit-for-bit equivalent to what `Runner.run`
+      # would have built on its own.
       #
-      # `DiagnosticPublisher` passes this env through
-      # `Runner.new(environment: …)` so per-buffer publishes share
-      # one instance instead of repeating the
-      # `Environment.for_project` build per call (bundler
-      # discovery, RbsLoader construction, signature_paths
-      # composition). Subsequent calls return the same instance
-      # until `#invalidate!` drops the cache.
+      # `DiagnosticPublisher` passes this env through `Runner.new(environment: …)` so per-buffer publishes
+      # share one instance instead of repeating the `Environment.for_project` build per call (bundler
+      # discovery, RbsLoader construction, signature_paths composition). Subsequent calls return the same
+      # instance until `#invalidate!` drops the cache.
       #
-      # The runner attaches its own per-call reporter pair onto
-      # the shared env's `Reporters` slot at the start of each
-      # `#analyze_files` — so diagnostic events stay scoped to a
-      # single publish and do NOT accumulate across publishes.
+      # The runner attaches its own per-call reporter pair onto the shared env's `Reporters` slot at the start
+      # of each `#analyze_files` — so diagnostic events stay scoped to a single publish and do NOT accumulate
+      # across publishes.
       def environment
         @environment ||= Environment.for_project(
           libraries: @configuration.libraries,
@@ -98,35 +75,30 @@ module Rigor
         )
       end
 
-      # Returns the per-session read-only `Cache::Store`. Read-only
-      # so multiple LSP sessions against the same project don't
-      # race on cache writes — same contract editor mode v1 already
-      # uses for the CLI `--tmp-file` path.
+      # Returns the per-session read-only `Cache::Store`. Read-only so multiple LSP sessions against the same
+      # project don't race on cache writes — same contract editor mode v1 already uses for the CLI
+      # `--tmp-file` path.
       def cache_store
         @cache_store ||= Cache::Store.new(root: @configuration.cache_path, read_only: true)
       end
 
-      # Returns the cached {Rigor::Analysis::ProjectScan} for this
-      # session, building it lazily by spinning up a project-only
-      # `Runner` (no buffer binding, no `paths` override) and
-      # calling `#prepare_project_scan`. The cold build pays the
-      # full pre-pass cost once per generation; every subsequent
+      # Returns the cached {Rigor::Analysis::ProjectScan} for this session, building it lazily by spinning up a
+      # project-only `Runner` (no buffer binding, no `paths` override) and calling `#prepare_project_scan`. The
+      # cold build pays the full pre-pass cost once per generation; every subsequent
       # `Runner.new(prebuilt: project_scan)` skips it.
       def project_scan
         @project_scan ||= build_project_scan
       end
 
-      # Drops every cached collaborator and bumps the generation.
-      # The next reader rebuilds from scratch. Triggered by
-      # `workspace/didChangeWatchedFiles` for project source files
-      # and by `workspace/didChangeConfiguration`.
+      # Drops every cached collaborator and bumps the generation. The next reader rebuilds from scratch.
+      # Triggered by `workspace/didChangeWatchedFiles` for project source files and by
+      # `workspace/didChangeConfiguration`.
       def invalidate!
         @generation += 1
         @environment = nil
         @project_scan = nil
-        # Cache store stays — it's content-addressed; a stale env
-        # build won't be served because the file digest mixed into
-        # the cache key has changed.
+        # Cache store stays — it's content-addressed; a stale env build won't be served because the file
+        # digest mixed into the cache key has changed.
         nil
       end
 

data/lib/rigor/language_server/selection_range_provider.rb

@@ -7,12 +7,10 @@ require_relative "buffer_resolution"
 
 module Rigor
   module LanguageServer
-    # Answers `textDocument/selectionRange` requests. For each
-    # position, returns a linked list of SelectionRange entries —
-    # innermost first, each pointing at its `parent` (the next-
-    # wider expression). Editors use this for "expand selection":
-    # one keystroke moves up the chain, another moves further out,
-    # all the way to the root.
+    # Answers `textDocument/selectionRange` requests. For each position, returns a linked list of
+    # SelectionRange entries — innermost first, each pointing at its `parent` (the next-wider expression).
+    # Editors use this for "expand selection": one keystroke moves up the chain, another moves further out, all
+    # the way to the root.
     class SelectionRangeProvider
       include BufferResolution
 
@@ -43,8 +41,8 @@ module Rigor
 
       private
 
-      # Walks the AST top-down; each node whose location encloses
-      # `offset` gets appended to the chain. Returns root→innermost.
+      # Walks the AST top-down; each node whose location encloses `offset` gets appended to the chain. Returns
+      # root→innermost.
       def ancestor_chain(node, offset, chain = [])
         return chain unless node.is_a?(Prism::Node)
         return chain unless node.location && offset_in?(node.location, offset)
@@ -58,10 +56,9 @@ module Rigor
         offset.between?(location.start_offset, location.end_offset)
       end
 
-      # Folds the root→innermost chain into the LSP `SelectionRange`
-      # linked-list shape — innermost on the outside (the request's
-      # return value) with `parent` chained outward. Editor "expand
-      # selection" follows `.parent` one step per invocation.
+      # Folds the root→innermost chain into the LSP `SelectionRange` linked-list shape — innermost on the
+      # outside (the request's return value) with `parent` chained outward. Editor "expand selection" follows
+      # `.parent` one step per invocation.
       def build_chain(root, offset)
         chain = ancestor_chain(root, offset)
         return nil if chain.empty?