rigortype 0.1.5 → 0.1.6

data/lib/rigor/language_server/project_context.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require_relative "../environment"
+require_relative "../cache/store"
+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.
+    #
+    # 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.
+    #
+    # 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
+
+      def initialize(configuration:)
+        @configuration = configuration
+        @generation = 0
+        @environment = nil
+        @cache_store = nil
+        @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.
+      #
+      # `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.
+      def environment
+        @environment ||= Environment.for_project(
+          libraries: @configuration.libraries,
+          signature_paths: @configuration.signature_paths,
+          cache_store: cache_store,
+          plugin_registry: project_scan.plugin_registry,
+          dependency_source_index: project_scan.dependency_source_index,
+          synthetic_method_index: project_scan.synthetic_method_index,
+          project_patched_methods: project_scan.project_patched_methods,
+          bundler_bundle_path: @configuration.bundler_bundle_path,
+          bundler_auto_detect: @configuration.bundler_auto_detect,
+          bundler_lockfile: @configuration.bundler_lockfile,
+          rbs_collection_lockfile: @configuration.rbs_collection_lockfile,
+          rbs_collection_auto_detect: @configuration.rbs_collection_auto_detect
+        )
+      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.
+      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
+      # `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`.
+      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.
+        nil
+      end
+
+      private
+
+      def build_project_scan
+        runner = Analysis::Runner.new(
+          configuration: @configuration,
+          cache_store: cache_store,
+          collect_stats: false
+        )
+        runner.prepare_project_scan
+      end
+    end
+  end
+end

data/lib/rigor/language_server/selection_range_provider.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "uri"
+
+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.
+    class SelectionRangeProvider
+      def initialize(buffer_table:, project_context:)
+        @buffer_table = buffer_table
+        @project_context = project_context
+      end
+
+      # @param positions [Array<Hash>] LSP `Position[]` — each
+      #   `{ line:, character: }` 0-based.
+      # @return [Array<Hash>, nil] one `SelectionRange` per
+      #   position, or nil when the URI / buffer isn't resolvable.
+      def provide(uri, positions)
+        path = Uri.to_path(uri)
+        return nil if path.nil?
+
+        entry = @buffer_table[uri]
+        return nil if entry.nil?
+
+        parse_result = Prism.parse(entry.bytes, filepath: path,
+                                                version: @project_context.configuration.target_ruby)
+        root = parse_result.value
+
+        positions.map do |pos|
+          offset = byte_offset_for(entry.bytes, pos.fetch(:line), pos.fetch(:character))
+          next nil if offset.nil?
+
+          build_chain(root, offset)
+        end
+      end
+
+      private
+
+      # 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)
+
+        chain << node
+        node.compact_child_nodes.each { |child| ancestor_chain(child, offset, chain) }
+        chain
+      end
+
+      def offset_in?(location, offset)
+        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.
+      def build_chain(root, offset)
+        chain = ancestor_chain(root, offset)
+        return nil if chain.empty?
+
+        chain.reduce(nil) do |parent, node|
+          { range: lsp_range(node), parent: parent }
+        end
+      end
+
+      def lsp_range(node)
+        loc = node.location
+        {
+          start: { line: loc.start_line - 1, character: loc.start_column },
+          end: { line: loc.end_line - 1,   character: loc.end_column }
+        }
+      end
+
+      def byte_offset_for(bytes, line, character)
+        offset = 0
+        bytes.each_line.with_index do |line_bytes, idx|
+          return offset + character if idx == line
+
+          offset += line_bytes.bytesize
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/rigor/language_server/server.rb

@@ -0,0 +1,384 @@
+# frozen_string_literal: true
+
+require_relative "../version"
+require_relative "buffer_table"
+
+module Rigor
+  module LanguageServer
+    # LSP server lifecycle state machine + JSON-RPC method dispatcher.
+    #
+    # Slice 1 (this commit) ships:
+    # - State machine: `:uninitialized` → `:initialized` → `:shutdown`
+    #   → `:exited`.
+    # - Three lifecycle handlers: `initialize`, `shutdown`, `exit`.
+    # - {#dispatch} which routes (method, params) to the matching
+    #   handler and returns the response payload (or `nil` for
+    #   notifications). Out-of-state requests return the
+    #   spec-defined `InvalidRequest` (-32002) / `MethodNotFound`
+    #   (-32601) error shapes.
+    #
+    # Slice 2 wraps this dispatcher in a stdio JSON-RPC reader /
+    # writer so the CLI subcommand can serve real LSP clients.
+    # Slice 3+ adds document sync; slice 4+ adds publishDiagnostics;
+    # slice 5-8 add the rest of the v1 capability surface.
+    class Server # rubocop:disable Metrics/ClassLength
+      # JSON-RPC error codes per LSP spec § "Response Message".
+      ERROR_PARSE_ERROR      = -32_700
+      ERROR_INVALID_REQUEST  = -32_600
+      ERROR_METHOD_NOT_FOUND = -32_601
+      ERROR_INVALID_PARAMS   = -32_602
+      ERROR_INTERNAL_ERROR   = -32_603
+      # LSP-specific reserved codes.
+      ERROR_SERVER_NOT_INITIALIZED = -32_002
+      ERROR_INVALID_REQUEST_AFTER_SHUTDOWN = -32_600
+
+      # `TextDocumentSyncKind::Full = 1`. Slice 10 (deferred)
+      # promotes to `Incremental = 2`.
+      TEXT_DOCUMENT_SYNC_FULL = 1
+
+      # Methods callable BEFORE `initialize`. Per LSP spec § 3 only
+      # `initialize` and `exit` are allowed pre-initialization; every
+      # other request returns `ServerNotInitialized`. We also accept
+      # `shutdown` so a sequence like `initialize → shutdown → exit`
+      # (the conformance harness) round-trips even when the client
+      # skips real work.
+      PRE_INITIALIZE_METHODS = %w[initialize shutdown exit].freeze
+
+      attr_reader :state, :exit_code, :buffer_table, :publisher,
+                  :hover_provider, :document_symbol_provider, :completion_provider,
+                  :signature_help_provider, :folding_range_provider,
+                  :selection_range_provider, :project_context
+
+      # @param completion_provider [Rigor::LanguageServer::CompletionProvider, nil]
+      #   resolves `textDocument/completion`. Nil → `MethodNotFound`.
+      # @param signature_help_provider [Rigor::LanguageServer::SignatureHelpProvider, nil]
+      #   resolves `textDocument/signatureHelp`. Nil → `MethodNotFound`.
+      # @param project_context [Rigor::LanguageServer::ProjectContext, nil]
+      #   the per-session cache of `Environment` + `Cache::Store`
+      #   the providers read on every request. When present,
+      #   `workspace/didChangeWatchedFiles` and
+      #   `workspace/didChangeConfiguration` invalidate the cache;
+      #   nil means "no project context", which is the slice 1-6
+      #   behaviour (each request rebuilds env from scratch).
+      def initialize(buffer_table: BufferTable.new, publisher: nil, # rubocop:disable Metrics/ParameterLists
+                     hover_provider: nil, document_symbol_provider: nil,
+                     completion_provider: nil, signature_help_provider: nil,
+                     folding_range_provider: nil, selection_range_provider: nil,
+                     project_context: nil)
+        @state = :uninitialized
+        @exit_code = nil
+        @buffer_table = buffer_table
+        @publisher = publisher
+        @hover_provider = hover_provider
+        @document_symbol_provider = document_symbol_provider
+        @completion_provider = completion_provider
+        @signature_help_provider = signature_help_provider
+        @folding_range_provider = folding_range_provider
+        @selection_range_provider = selection_range_provider
+        @project_context = project_context
+      end
+
+      # @return [Boolean] true once the client has called `exit` and
+      #   the server has set its terminal exit code. The CLI loop
+      #   reads this between dispatches to know when to stop.
+      def exited?
+        @state == :exited
+      end
+
+      # Routes one LSP method call.
+      #
+      # @param method [String] the LSP method name (e.g. "initialize").
+      # @param params [Hash, nil] the LSP `params` payload (Hash for
+      #   request / notification methods; nil for the empty case).
+      # @return [Hash, nil] one of:
+      #   - the response result Hash for request methods,
+      #   - nil for notification methods,
+      #   - { error: { code:, message: } } for state / shape errors.
+      def dispatch(method, params = nil) # rubocop:disable Metrics/CyclomaticComplexity
+        return state_violation_response(method) unless method_allowed_in_state?(method)
+
+        case method
+        when "initialize"             then handle_initialize(params)
+        when "initialized"            then handle_initialized
+        when "shutdown"               then handle_shutdown
+        when "exit"                   then handle_exit
+        when "textDocument/didOpen"   then handle_did_open(params)
+        when "textDocument/didChange" then handle_did_change(params)
+        when "textDocument/didClose"  then handle_did_close(params)
+        when "textDocument/hover"               then handle_hover(params)
+        when "textDocument/documentSymbol"      then handle_document_symbol(params)
+        when "textDocument/completion"          then handle_completion(params)
+        when "textDocument/signatureHelp"       then handle_signature_help(params)
+        when "textDocument/foldingRange"        then handle_folding_range(params)
+        when "textDocument/selectionRange"      then handle_selection_range(params)
+        when "workspace/didChangeWatchedFiles"  then handle_did_change_watched_files(params)
+        when "workspace/didChangeConfiguration" then handle_did_change_configuration(params)
+        else
+          method_not_found(method)
+        end
+      end
+
+      private
+
+      def method_allowed_in_state?(method)
+        case @state
+        when :uninitialized then PRE_INITIALIZE_METHODS.include?(method)
+        when :initialized   then method != "initialize"
+        when :shutdown      then method == "exit"
+        when :exited        then false
+        end
+      end
+
+      def state_violation_response(method)
+        case @state
+        when :uninitialized
+          rpc_error(
+            ERROR_SERVER_NOT_INITIALIZED,
+            "method #{method.inspect} requires `initialize` first"
+          )
+        when :initialized
+          rpc_error(
+            ERROR_INVALID_REQUEST,
+            "method #{method.inspect} is not valid after `initialize` has succeeded"
+          )
+        when :shutdown
+          rpc_error(
+            ERROR_INVALID_REQUEST_AFTER_SHUTDOWN,
+            "method #{method.inspect} is not valid after `shutdown`; only `exit` is accepted"
+          )
+        when :exited
+          rpc_error(ERROR_INVALID_REQUEST, "server has exited")
+        end
+      end
+
+      # Per LSP spec § "Server lifecycle / initialize": the server
+      # responds with its capabilities. Each later slice extends
+      # `advertised_capabilities` with the handler it wires;
+      # clients asking for unadvertised methods get `MethodNotFound`.
+      def handle_initialize(_params)
+        @state = :initialized
+        {
+          capabilities: advertised_capabilities,
+          serverInfo: {
+            name: "rigor-lsp",
+            version: Rigor::VERSION
+          }
+        }
+      end
+
+      def advertised_capabilities
+        caps = {
+          textDocumentSync: {
+            openClose: true,
+            change: TEXT_DOCUMENT_SYNC_FULL
+          }
+        }
+        caps[:hoverProvider] = true if @hover_provider
+        caps[:documentSymbolProvider] = true if @document_symbol_provider
+        if @completion_provider
+          caps[:completionProvider] = {
+            # `.` for method completion; `:` for constant-path
+            # completion (slice 6). The server detects which form
+            # by looking one character back when `:` triggers.
+            triggerCharacters: [".", ":"],
+            # v1 eager — full payload returned on first request.
+            # Resolve becomes relevant if large enumerations
+            # (Object descendants) become noticeable.
+            resolveProvider: false
+          }
+        end
+        if @signature_help_provider
+          caps[:signatureHelpProvider] = {
+            # `(` opens the argument list; `,` advances to the
+            # next argument. Editors retrigger on both.
+            triggerCharacters: ["(", ","]
+          }
+        end
+        caps[:foldingRangeProvider] = true if @folding_range_provider
+        caps[:selectionRangeProvider] = true if @selection_range_provider
+        caps
+      end
+
+      # `initialized` is a notification — no response body. Slice 7
+      # will hook this to register `workspace/didChangeWatchedFiles`
+      # if the client advertised the capability.
+      def handle_initialized
+        nil
+      end
+
+      def handle_shutdown
+        @state = :shutdown
+        # Drop any in-flight debounced publishes so they don't
+        # fire after the client has stopped listening.
+        @publisher&.cancel_pending
+        nil
+      end
+
+      def handle_exit
+        @exit_code = @state == :shutdown ? 0 : 1
+        @state = :exited
+        nil
+      end
+
+      # textDocument/didOpen notification. Per LSP spec § the
+      # `textDocument` payload carries `uri`, `languageId`,
+      # `version`, and the full initial `text`. Triggers a
+      # `publishDiagnostics` push when a publisher is wired.
+      def handle_did_open(params)
+        doc = params.fetch(:textDocument)
+        uri = doc.fetch(:uri)
+        @buffer_table.open(
+          uri: uri,
+          bytes: doc.fetch(:text),
+          version: doc.fetch(:version)
+        )
+        @publisher&.publish_for(uri)
+        nil
+      end
+
+      # textDocument/didChange under FULL sync. Each `contentChanges`
+      # entry carries only `{ text: }`; the LAST entry is the new
+      # full document text. Per LSP spec § "FULL sync" the array
+      # MUST be exactly one entry in practice — we still take
+      # `.last` defensively for clients that pad. Triggers
+      # `publishDiagnostics` afterwards.
+      def handle_did_change(params)
+        doc = params.fetch(:textDocument)
+        changes = params.fetch(:contentChanges)
+        return nil if changes.empty?
+
+        uri = doc.fetch(:uri)
+        @buffer_table.change(
+          uri: uri,
+          bytes: changes.last.fetch(:text),
+          version: doc.fetch(:version)
+        )
+        @publisher&.publish_for(uri)
+        nil
+      end
+
+      # textDocument/hover REQUEST. Slice 5 returns either a
+      # `Hover` payload (markdown contents wrapping type +
+      # erased-RBS info) or nil when no expression is at the
+      # queried position. Nil maps to `result: null` per LSP
+      # spec; clients suppress the popup. Returns
+      # `MethodNotFound` when no hover_provider is wired (slice
+      # 1-4 behaviour).
+      def handle_hover(params)
+        return method_not_found("textDocument/hover") unless @hover_provider
+
+        doc = params.fetch(:textDocument)
+        pos = params.fetch(:position)
+        @hover_provider.provide(
+          uri: doc.fetch(:uri),
+          line: pos.fetch(:line),
+          character: pos.fetch(:character)
+        )
+      end
+
+      # workspace/didChangeWatchedFiles NOTIFICATION. Invalidates
+      # the ProjectContext so cached pre-pass / Environment is
+      # rebuilt on the next request. Slice 7's floor: any watched
+      # file change triggers a full context rebuild. Per-file
+      # surgical invalidation (per design doc § "Project context
+      # refresh") is a follow-up; this is the LSP-correct floor.
+      def handle_did_change_watched_files(_params)
+        @project_context&.invalidate!
+        nil
+      end
+
+      # workspace/didChangeConfiguration NOTIFICATION. The payload
+      # shape is client-specific; v1 ignores the payload and
+      # invalidates the context so the next read picks up any
+      # external config changes (.rigor.yml / Gemfile.lock / etc).
+      def handle_did_change_configuration(_params)
+        @project_context&.invalidate!
+        nil
+      end
+
+      # textDocument/selectionRange REQUEST. Routes to the
+      # selection-range provider when wired; `MethodNotFound`
+      # otherwise.
+      def handle_selection_range(params)
+        return method_not_found("textDocument/selectionRange") unless @selection_range_provider
+
+        doc = params.fetch(:textDocument)
+        positions = params.fetch(:positions)
+        @selection_range_provider.provide(doc.fetch(:uri), positions)
+      end
+
+      # textDocument/foldingRange REQUEST. Routes to the
+      # folding-range provider when wired; `MethodNotFound`
+      # otherwise.
+      def handle_folding_range(params)
+        return method_not_found("textDocument/foldingRange") unless @folding_range_provider
+
+        doc = params.fetch(:textDocument)
+        @folding_range_provider.provide(doc.fetch(:uri))
+      end
+
+      # textDocument/signatureHelp REQUEST. Routes to the
+      # signature-help provider when wired; `MethodNotFound`
+      # otherwise.
+      def handle_signature_help(params)
+        return method_not_found("textDocument/signatureHelp") unless @signature_help_provider
+
+        doc = params.fetch(:textDocument)
+        pos = params.fetch(:position)
+        context = params[:context]
+        @signature_help_provider.provide(
+          uri: doc.fetch(:uri),
+          line: pos.fetch(:line),
+          character: pos.fetch(:character),
+          context: context
+        )
+      end
+
+      # textDocument/completion REQUEST. Routes to the completion
+      # provider when wired; `MethodNotFound` otherwise.
+      def handle_completion(params)
+        return method_not_found("textDocument/completion") unless @completion_provider
+
+        doc = params.fetch(:textDocument)
+        pos = params.fetch(:position)
+        context = params[:context] || {}
+        @completion_provider.provide(
+          uri: doc.fetch(:uri),
+          line: pos.fetch(:line),
+          character: pos.fetch(:character),
+          trigger_character: context[:triggerCharacter]
+        )
+      end
+
+      # textDocument/documentSymbol REQUEST. Returns the
+      # `DocumentSymbol[]` outline for the buffer at the requested
+      # URI. Returns `MethodNotFound` when no provider is wired.
+      def handle_document_symbol(params)
+        return method_not_found("textDocument/documentSymbol") unless @document_symbol_provider
+
+        doc = params.fetch(:textDocument)
+        @document_symbol_provider.provide(doc.fetch(:uri))
+      end
+
+      # textDocument/didClose. Drops the buffer table entry AND
+      # publishes an empty diagnostic set so clients clear inline
+      # markers — per LSP spec § "publishDiagnostics" the standard
+      # way to indicate "no diagnostics remain for this URI".
+      def handle_did_close(params)
+        doc = params.fetch(:textDocument)
+        uri = doc.fetch(:uri)
+        @buffer_table.close(uri: uri)
+        @publisher&.publish_empty(uri)
+        nil
+      end
+
+      def method_not_found(method)
+        rpc_error(ERROR_METHOD_NOT_FOUND, "method not found: #{method.inspect}")
+      end
+
+      def rpc_error(code, message)
+        { error: { code: code, message: message } }
+      end
+    end
+  end
+end