steep 0.37.0 → 0.42.0

data/lib/steep/range_extension.rb

@@ -0,0 +1,29 @@
+class RBS::Location
+  def as_lsp_range
+    {
+      start: {
+          line: start_line - 1,
+          character: start_column
+      },
+      end: {
+        line: end_line - 1,
+        character: end_column
+      }
+    }
+  end
+end
+
+class Parser::Source::Range
+  def as_lsp_range
+    {
+      start: {
+        line: line - 1,
+        character: column
+      },
+      end: {
+        line: last_line - 1,
+        character: last_column
+      }
+    }
+  end
+end

data/lib/steep/server/base_worker.rb

@@ -3,18 +3,31 @@ module Steep
     class BaseWorker
       LSP = LanguageServer::Protocol
 
-      include Utils
-
       attr_reader :project
-      attr_reader :reader, :writer
+      attr_reader :reader, :writer, :queue
+
+      ShutdownJob = Struct.new(:id, keyword_init: true)
 
       def initialize(project:, reader:, writer:)
         @project = project
         @reader = reader
         @writer = writer
+        @skip_job = false
         @shutdown = false
       end
 
+      def skip_jobs_after_shutdown!(flag = true)
+        @skip_jobs_after_shutdown = flag
+      end
+
+      def skip_jobs_after_shutdown?
+        @skip_jobs_after_shutdown
+      end
+
+      def skip_job?
+        @skip_job
+      end
+
       def handle_request(request)
         # process request
       end
@@ -29,7 +42,29 @@ module Steep
           Steep.logger.formatter.push_tags(*tags)
           Steep.logger.tagged "background" do
             while job = queue.pop
-              handle_job(job) unless @shutdown
+              case job
+              when ShutdownJob
+                writer.write(id: job.id, result: nil)
+              else
+                if skip_job?
+                  Steep.logger.info "Skipping job..."
+                else
+                  begin
+                    handle_job(job)
+                  rescue => exn
+                    Steep.log_error exn
+                    writer.write(
+                      {
+                        method: "window/showMessage",
+                        params: {
+                          type: LSP::Constant::MessageType::ERROR,
+                          message: "Unexpected error: #{exn.message} (#{exn.class})"
+                        }
+                      }
+                    )
+                  end
+                end
+              end
             end
           end
         end
@@ -37,10 +72,12 @@ module Steep
         Steep.logger.tagged "frontend" do
           begin
             reader.read do |request|
+              Steep.logger.info "Received message from master: #{request[:method]}(#{request[:id]})"
               case request[:method]
               when "shutdown"
-                @shutdown = true
-                writer.write(id: request[:id], result: nil)
+                queue << ShutdownJob.new(id: request[:id])
+                @skip_job = skip_jobs_after_shutdown?
+                queue.close
               when "exit"
                 break
               else
@@ -48,7 +85,6 @@ module Steep
               end
             end
           ensure
-            queue << nil
             thread.join
           end
         end

data/lib/steep/server/change_buffer.rb

@@ -0,0 +1,63 @@
+module Steep
+  module Server
+    module ChangeBuffer
+      attr_reader :mutex
+      attr_reader :buffered_changes
+
+      def push_buffer
+        @mutex.synchronize do
+          yield buffered_changes
+        end
+      end
+
+      def pop_buffer
+        changes = {}
+        @mutex.synchronize do
+          changes.merge!(buffered_changes)
+          buffered_changes.clear
+        end
+        if block_given?
+          yield changes
+        else
+          changes
+        end
+      end
+
+      def load_files(project:, commandline_args:)
+        Steep.logger.tagged "#load_files" do
+          push_buffer do |changes|
+            loader = Services::FileLoader.new(base_dir: project.base_dir)
+
+            Steep.measure "load changes from disk" do
+              project.targets.each do |target|
+                loader.load_changes(target.source_pattern, commandline_args, changes: changes)
+                loader.load_changes(target.signature_pattern, changes: changes)
+              end
+            end
+          end
+        end
+      end
+
+      def collect_changes(request)
+        push_buffer do |changes|
+          path = project.relative_path(Pathname(URI.parse(request[:params][:textDocument][:uri]).path))
+          version = request[:params][:textDocument][:version]
+          Steep.logger.info { "Updating source: path=#{path}, version=#{version}..." }
+
+          changes[path] ||= []
+          request[:params][:contentChanges].each do |change|
+            changes[path] << Services::ContentChange.new(
+              range: change[:range]&.yield_self {|range|
+                [
+                  range[:start].yield_self {|pos| Services::ContentChange::Position.new(line: pos[:line] + 1, column: pos[:character]) },
+                  range[:end].yield_self {|pos| Services::ContentChange::Position.new(line: pos[:line] + 1, column: pos[:character]) }
+                ]
+              },
+              text: change[:text]
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/server/interaction_worker.rb

@@ -1,38 +1,63 @@
 module Steep
   module Server
     class InteractionWorker < BaseWorker
-      attr_reader :queue
+      include ChangeBuffer
+
+      ApplyChangeJob = Class.new()
+      HoverJob = Struct.new(:id, :path, :line, :column, keyword_init: true)
+      CompletionJob = Struct.new(:id, :path, :line, :column, :trigger, keyword_init: true)
+
+      attr_reader :service
 
       def initialize(project:, reader:, writer:, queue: Queue.new)
         super(project: project, reader: reader, writer: writer)
         @queue = queue
+        @service = Services::TypeCheckService.new(project: project, assignment: Services::PathAssignment.all)
+        service.no_type_checking!
+        @mutex = Mutex.new
+        @buffered_changes = {}
       end
 
       def handle_job(job)
-        Steep.logger.debug "Handling job: id=#{job[:id]}, result=#{job[:result]&.to_hash}"
-        writer.write(job)
+        Steep.logger.tagged "#handle_job" do
+          changes = pop_buffer()
+
+          unless changes.empty?
+            Steep.logger.debug { "Applying changes for #{changes.size} files..." }
+            service.update(changes: changes) {}
+          end
+
+          case job
+          when ApplyChangeJob
+            # nop
+          when HoverJob
+            writer.write({ id: job.id, result: process_hover(job) })
+          when CompletionJob
+            writer.write({ id: job.id, result: process_completion(job) })
+          end
+        end
       end
 
       def handle_request(request)
         case request[:method]
         when "initialize"
-          # nop
+          load_files(project: project, commandline_args: [])
+          queue << ApplyChangeJob.new
+          writer.write({ id: request[:id], result: nil })
 
         when "textDocument/didChange"
-          update_source(request)
+          collect_changes(request)
+          queue << ApplyChangeJob.new
 
         when "textDocument/hover"
           id = request[:id]
 
           uri = URI.parse(request[:params][:textDocument][:uri])
           path = project.relative_path(Pathname(uri.path))
-          line = request[:params][:position][:line]
+          line = request[:params][:position][:line]+1
           column = request[:params][:position][:character]
 
-          queue << {
-            id: id,
-            result: response_to_hover(path: path, line: line, column: column)
-          }
+          queue << HoverJob.new(id: id, path: path, line: line, column: column)
 
         when "textDocument/completion"
           id = request[:id]
@@ -43,20 +68,17 @@ module Steep
           line, column = params[:position].yield_self {|hash| [hash[:line]+1, hash[:character]] }
           trigger = params[:context][:triggerCharacter]
 
-          queue << {
-            id: id,
-            result: response_to_completion(path: path, line: line, column: column, trigger: trigger)
-          }
+          queue << CompletionJob.new(id: id, path: path, line: line, column: column, trigger: trigger)
         end
       end
 
-      def response_to_hover(path:, line:, column:)
-        Steep.logger.tagged "#response_to_hover" do
-          Steep.measure "Generating response" do
-            Steep.logger.info { "path=#{path}, line=#{line}, column=#{column}" }
+      def process_hover(job)
+        Steep.logger.tagged "#process_hover" do
+          Steep.measure "Generating hover response" do
+            Steep.logger.info { "path=#{job.path}, line=#{job.line}, column=#{job.column}" }
 
-            hover = Project::HoverContent.new(project: project)
-            content = hover.content_for(path: path, line: line+1, column: column+1)
+            hover = Services::HoverContent.new(service: service)
+            content = hover.content_for(path: job.path, line: job.line, column: job.column+1)
             if content
               range = content.location.yield_self do |location|
                 start_position = { line: location.line - 1, character: location.column }
@@ -69,22 +91,22 @@ module Steep
                 range: range
               )
             end
+          rescue Typing::UnknownNodeError => exn
+            Steep.log_error exn, message: "Failed to compute hover: #{exn.inspect}"
+            nil
           end
-        rescue Typing::UnknownNodeError => exn
-          Steep.log_error exn, message: "Failed to compute hover: #{exn.inspect}"
-          nil
         end
       end
 
       def format_hover(content)
         case content
-        when Project::HoverContent::VariableContent
+        when Services::HoverContent::VariableContent
           "`#{content.name}`: `#{content.type.to_s}`"
-        when Project::HoverContent::MethodCallContent
+        when Services::HoverContent::MethodCallContent
           method_name = case content.method_name
-                        when Project::HoverContent::InstanceMethodName
+                        when Services::HoverContent::InstanceMethodName
                           "#{content.method_name.class_name}##{content.method_name.method_name}"
-                        when Project::HoverContent::SingletonMethodName
+                        when Services::HoverContent::SingletonMethodName
                           "#{content.method_name.class_name}.#{content.method_name.method_name}"
                         else
                           nil
@@ -106,7 +128,7 @@ HOVER
           else
             "`#{content.type}`"
           end
-        when Project::HoverContent::DefinitionContent
+        when Services::HoverContent::DefinitionContent
           string = <<HOVER
 ```
 def #{content.method_name}: #{content.method_type}
@@ -121,42 +143,37 @@ HOVER
           end
 
           string
-        when Project::HoverContent::TypeContent
+        when Services::HoverContent::TypeContent
           "`#{content.type}`"
         end
       end
 
-      def response_to_completion(path:, line:, column:, trigger:)
+      def process_completion(job)
         Steep.logger.tagged("#response_to_completion") do
           Steep.measure "Generating response" do
-            Steep.logger.info "path: #{path}, line: #{line}, column: #{column}, trigger: #{trigger}"
-
-            target = project.target_for_source_path(path) or return
-            target.type_check(target_sources: [], validate_signatures: false)
+            Steep.logger.info "path: #{job.path}, line: #{job.line}, column: #{job.column}, trigger: #{job.trigger}"
 
-            case (status = target&.status)
-            when Project::Target::TypeCheckStatus
-              subtyping = status.subtyping
-              source = target.source_files[path]
+            target = project.target_for_source_path(job.path) or return
+            file = service.source_files[job.path] or return
+            subtyping = service.signature_services[target.name].current_subtyping or return
 
-              provider = Project::CompletionProvider.new(source_text: source.content, path: path, subtyping: subtyping)
-              items = begin
-                        provider.run(line: line, column: column)
-                      rescue Parser::SyntaxError
-                        []
-                      end
+            provider = Services::CompletionProvider.new(source_text: file.content, path: job.path, subtyping: subtyping)
+            items = begin
+                      provider.run(line: job.line, column: job.column)
+                    rescue Parser::SyntaxError
+                      []
+                    end
 
-              completion_items = items.map do |item|
-                format_completion_item(item)
-              end
+            completion_items = items.map do |item|
+              format_completion_item(item)
+            end
 
-              Steep.logger.debug "items = #{completion_items.inspect}"
+            Steep.logger.debug "items = #{completion_items.inspect}"
 
-              LSP::Interface::CompletionList.new(
-                is_incomplete: false,
-                items: completion_items
-              )
-            end
+            LSP::Interface::CompletionList.new(
+              is_incomplete: false,
+              items: completion_items
+            )
           end
         end
       end
@@ -174,7 +191,7 @@ HOVER
         )
 
         case item
-        when Project::CompletionProvider::LocalVariableItem
+        when Services::CompletionProvider::LocalVariableItem
           LanguageServer::Protocol::Interface::CompletionItem.new(
             label: item.identifier,
             kind: LanguageServer::Protocol::Constant::CompletionItemKind::VARIABLE,
@@ -184,7 +201,7 @@ HOVER
               new_text: "#{item.identifier}"
             )
           )
-        when Project::CompletionProvider::MethodNameItem
+        when Services::CompletionProvider::MethodNameItem
           label = "def #{item.identifier}: #{item.method_type}"
           method_type_snippet = method_type_to_snippet(item.method_type)
           LanguageServer::Protocol::Interface::CompletionItem.new(
@@ -198,7 +215,7 @@ HOVER
             insert_text_format: LanguageServer::Protocol::Constant::InsertTextFormat::SNIPPET,
             sort_text: item.inherited? ? 'z' : 'a' # Ensure language server puts non-inherited methods before inherited methods
           )
-        when Project::CompletionProvider::InstanceVariableItem
+        when Services::CompletionProvider::InstanceVariableItem
           label = "#{item.identifier}: #{item.type}"
           LanguageServer::Protocol::Interface::CompletionItem.new(
             label: label,

data/lib/steep/server/master.rb

@@ -6,182 +6,318 @@ module Steep
       attr_reader :steepfile
       attr_reader :project
       attr_reader :reader, :writer
-      attr_reader :queue
-      attr_reader :worker_count
-      attr_reader :worker_to_paths
 
       attr_reader :interaction_worker
-      attr_reader :signature_worker
-      attr_reader :code_workers
+      attr_reader :typecheck_workers
+
+      attr_reader :response_handlers
+
+      # There are four types of threads:
+      #
+      # 1. Main thread -- Reads messages from client
+      # 2. Worker threads -- Reads messages from associated worker
+      # 3. Reconciliation thread -- Receives message from worker threads, reconciles, processes, and forwards to write thread
+      # 4. Write thread -- Writes messages to client
+      #
+      # We have two queues:
+      #
+      # 1. `recon_queue` is to pass messages from worker threads to reconciliation thread
+      # 2. `write` thread is to pass messages to write thread
+      #
+      # Message passing: Client -> Server (Master) -> Worker
+      #
+      # 1. Client -> Server
+      #   Master receives messages from the LSP client on main thread.
+      #
+      # 2. Master -> Worker
+      #   Master writes messages to workers on main thread.
+      #
+      # Message passing: Worker -> Server (Master) -> (reconciliation queue) -> (write queue) -> Client
+      #
+      # 3. Worker -> Master
+      #   Master receives messages on threads dedicated for each worker.
+      #   The messages sent from workers are then forwarded to the reconciliation thread through reconciliation queue.
+      #
+      # 4. Server -> Client
+      #   The reconciliation thread reads messages from reconciliation queue, does something, and finally sends messages to the client via write queue.
+      #
+      attr_reader :write_queue
+      attr_reader :recon_queue
+
+      class ResponseHandler
+        attr_reader :workers
+
+        attr_reader :request
+        attr_reader :responses
+
+        attr_reader :on_response_handlers
+        attr_reader :on_completion_handlers
+
+        def initialize(request:, workers:)
+          @workers = []
+
+          @request = request
+          @responses = workers.each.with_object({}) do |worker, hash|
+            hash[worker] = nil
+          end
+
+          @on_response_handlers = []
+          @on_completion_handlers = []
+        end
+
+        def on_response(&block)
+          on_response_handlers << block
+        end
+
+        def on_completion(&block)
+          on_completion_handlers << block
+        end
+
+        def request_id
+          request[:id]
+        end
+
+        def process_response(response, worker)
+          responses[worker] = response
+
+          on_response_handlers.each do |handler|
+            handler[worker, response]
+          end
 
-      include Utils
+          if completed?
+            on_completion_handlers.each do |handler|
+              handler[*responses.values]
+            end
+          end
+        end
 
-      def initialize(project:, reader:, writer:, interaction_worker:, signature_worker:, code_workers:, queue: Queue.new)
+        def completed?
+          responses.each_value.none?(&:nil?)
+        end
+      end
+
+      def initialize(project:, reader:, writer:, interaction_worker:, typecheck_workers:, queue: Queue.new)
         @project = project
         @reader = reader
         @writer = writer
-        @queue = queue
+        @write_queue = queue
+        @recon_queue = Queue.new
         @interaction_worker = interaction_worker
-        @signature_worker = signature_worker
-        @code_workers = code_workers
-        @worker_to_paths = {}
+        @typecheck_workers = typecheck_workers
         @shutdown_request_id = nil
+        @response_handlers = {}
       end
 
       def start
-        source_paths = project.all_source_files
-        bin_size = (source_paths.size / code_workers.size) + 1
-        source_paths.each_slice(bin_size).with_index do |paths, index|
-          register_code_to_worker(paths, worker: code_workers[index])
-        end
+        Steep.logger.tagged "master" do
+          tags = Steep.logger.formatter.current_tags.dup
 
-        tags = Steep.logger.formatter.current_tags.dup
-        tags << "master"
+          worker_threads = []
 
-        Thread.new do
-          Steep.logger.formatter.push_tags(*tags, "from-worker@interaction")
-          interaction_worker.reader.read do |message|
-            process_message_from_worker(message)
+          if interaction_worker
+            worker_threads << Thread.new do
+              Steep.logger.formatter.push_tags(*tags, "from-worker@interaction")
+              interaction_worker.reader.read do |message|
+                process_message_from_worker(message, worker: interaction_worker)
+              end
+            end
           end
-        end
 
-        Thread.new do
-          Steep.logger.formatter.push_tags(*tags, "from-worker@signature")
-          signature_worker.reader.read do |message|
-            process_message_from_worker(message)
+          typecheck_workers.each do |worker|
+            worker_threads << Thread.new do
+              Steep.logger.formatter.push_tags(*tags, "from-worker@#{worker.name}")
+              worker.reader.read do |message|
+                process_message_from_worker(message, worker: worker)
+              end
+            end
           end
-        end
 
-        code_workers.each do |worker|
-          Thread.new do
-            Steep.logger.formatter.push_tags(*tags, "from-worker@#{worker.name}")
-            worker.reader.read do |message|
-              process_message_from_worker(message)
+          worker_threads << Thread.new do
+            Steep.logger.formatter.push_tags(*tags, "write")
+            while message = write_queue.pop
+              writer.write(message)
             end
-          end
-        end
 
-        Thread.new do
-          Steep.logger.formatter.push_tags(*tags, "from-client")
-          reader.read do |request|
-            process_message_from_client(request)
+            writer.io.close
           end
-        end
 
-        while job = queue.pop
-          if @shutdown_request_id
-            if job[:id] == @shutdown_request_id
-              writer.write(job)
-              break
+          worker_threads << Thread.new do
+            Steep.logger.formatter.push_tags(*tags, "reconciliation")
+            while (message, worker = recon_queue.pop)
+              id = message[:id]
+              handler = response_handlers[id] or raise
+
+              Steep.logger.info "Processing response to #{handler.request[:method]}(#{id}) from #{worker.name}"
+
+              handler.process_response(message, worker)
+
+              if handler.completed?
+                Steep.logger.info "Response to #{handler.request[:method]}(#{id}) completed"
+                response_handlers.delete(id)
+              end
             end
-          else
-            writer.write(job)
           end
-        end
 
-        writer.io.close
+          Steep.logger.tagged "main" do
+            reader.read do |request|
+              process_message_from_client(request) or break
+            end
 
-        each_worker do |w|
-          w.shutdown()
+            worker_threads.each do |thread|
+              thread.join
+            end
+          end
         end
       end
 
       def each_worker(&block)
         if block_given?
-          yield interaction_worker
-          yield signature_worker
-          code_workers.each &block
+          yield interaction_worker if interaction_worker
+          typecheck_workers.each &block
         else
           enum_for :each_worker
         end
       end
 
       def process_message_from_client(message)
+        Steep.logger.info "Received message #{message[:method]}(#{message[:id]})"
         id = message[:id]
 
         case message[:method]
         when "initialize"
-          queue << {
-            id: id,
-            result: LSP::Interface::InitializeResult.new(
-              capabilities: LSP::Interface::ServerCapabilities.new(
-                text_document_sync: LSP::Interface::TextDocumentSyncOptions.new(
-                  change: LSP::Constant::TextDocumentSyncKind::INCREMENTAL
-                ),
-                hover_provider: true,
-                completion_provider: LSP::Interface::CompletionOptions.new(
-                  trigger_characters: [".", "@"]
+          broadcast_request(message) do |handler|
+            handler.on_completion do
+              write_queue << {
+                id: id,
+                result: LSP::Interface::InitializeResult.new(
+                  capabilities: LSP::Interface::ServerCapabilities.new(
+                    text_document_sync: LSP::Interface::TextDocumentSyncOptions.new(
+                      change: LSP::Constant::TextDocumentSyncKind::INCREMENTAL
+                    ),
+                    hover_provider: true,
+                    completion_provider: LSP::Interface::CompletionOptions.new(
+                      trigger_characters: [".", "@"]
+                    ),
+                    workspace_symbol_provider: true
+                  )
                 )
-              )
-            )
-          }
-
-          each_worker do |worker|
-            worker << message
+              }
+            end
           end
 
         when "textDocument/didChange"
-          update_source(message)
-
-          uri = URI.parse(message[:params][:textDocument][:uri])
-          path = project.relative_path(Pathname(uri.path))
-
-          unless registered_path?(path)
-            register_code_to_worker [path], worker: least_busy_worker()
+          broadcast_notification(message)
+
+        when "textDocument/hover", "textDocument/completion"
+          if interaction_worker
+            send_request(message, worker: interaction_worker) do |handler|
+              handler.on_completion do |response|
+                write_queue << response
+              end
+            end
           end
 
-          each_worker do |worker|
-            worker << message
-          end
+        when "textDocument/open"
+          # Ignores open notification
 
-        when "textDocument/hover"
-          interaction_worker << message
+        when "workspace/symbol"
+          send_request(message, workers: typecheck_workers) do |handler|
+            handler.on_completion do |*responses|
+              result = responses.flat_map {|resp| resp[:result] || [] }
 
-        when "textDocument/completion"
-          interaction_worker << message
+              write_queue << {
+                id: handler.request_id,
+                result: result
+              }
+            end
+          end
 
-        when "textDocument/open"
-          # Ignores open notification
+        when "workspace/executeCommand"
+          case message[:params][:command]
+          when "steep/stats"
+            send_request(message, workers: typecheck_workers) do |handler|
+              handler.on_completion do |*responses|
+                stats = responses.flat_map {|resp| resp[:result] }
+                write_queue << {
+                  id: handler.request_id,
+                  result: stats
+                }
+              end
+            end
+          end
 
         when "shutdown"
-          queue << { id: id, result: nil }
-          @shutdown_request_id = id
+          broadcast_request(message) do |handler|
+            handler.on_completion do |*_|
+              write_queue << { id: id, result: nil}
+
+              write_queue.close
+              recon_queue.close
+            end
+          end
 
         when "exit"
-          queue << nil
+          broadcast_notification(message)
+
+          return false
         end
+
+        true
       end
 
-      def process_message_from_worker(message)
-        queue << message
+      def broadcast_notification(message)
+        Steep.logger.info "Broadcasting notification #{message[:method]}"
+        each_worker do |worker|
+          worker << message
+        end
       end
 
-      def paths_for(worker)
-        worker_to_paths[worker] ||= Set[]
+      def send_notification(message, worker:)
+        Steep.logger.info "Sending notification #{message[:method]} to #{worker.name}"
+        worker << message
       end
 
-      def least_busy_worker
-        code_workers.min_by do |w|
-          paths_for(w).size
+      def send_request(message, worker: nil, workers: [])
+        workers << worker if worker
+
+        Steep.logger.info "Sending request #{message[:method]}(#{message[:id]}) to #{workers.map(&:name).join(", ")}"
+        handler = ResponseHandler.new(request: message, workers: workers)
+        yield(handler) if block_given?
+        response_handlers[handler.request_id] = handler
+
+        workers.each do |w|
+          w << message
         end
       end
 
-      def registered_path?(path)
-        worker_to_paths.each_value.any? {|set| set.include?(path) }
+      def broadcast_request(message)
+        Steep.logger.info "Broadcasting request #{message[:method]}(#{message[:id]})"
+        handler = ResponseHandler.new(request: message, workers: each_worker.to_a)
+        yield(handler) if block_given?
+        response_handlers[handler.request_id] = handler
+
+        each_worker do |worker|
+          worker << message
+        end
       end
 
-      def register_code_to_worker(paths, worker:)
-        paths_for(worker).merge(paths)
+      def process_message_from_worker(message, worker:)
+        case
+        when message.key?(:id) && !message.key?(:method)
+          # Response from worker
+          Steep.logger.debug { "Received response #{message[:id]} from worker" }
+          recon_queue << [message, worker]
+        when message.key?(:method) && !message.key?(:id)
+          # Notification from worker
+          Steep.logger.debug { "Received notification #{message[:method]} from worker" }
+          write_queue << message
+        end
+      end
 
-        worker << {
-          method: "workspace/executeCommand",
-          params: LSP::Interface::ExecuteCommandParams.new(
-            command: "steep/registerSourceToWorker",
-            arguments: paths.map do |path|
-              "file://#{project.absolute_path(path)}"
-            end
-          )
-        }
+      def kill
+        each_worker do |worker|
+          worker.kill
+        end
       end
     end
   end