steep 0.42.0 → 0.43.0

data/lib/steep/drivers/utils/driver_helper.rb

@@ -20,6 +20,41 @@ module Steep
             end
           end
         end
+
+        def request_id
+          SecureRandom.alphanumeric(10)
+        end
+
+        def wait_for_response_id(reader:, id:, unknown_responses: :ignore)
+          wait_for_message(reader: reader, unknown_messages: unknown_responses) do |response|
+            response[:id] == id
+          end
+        end
+
+        def shutdown_exit(writer:, reader:)
+          request_id().tap do |id|
+            writer.write({ method: :shutdown, id: id })
+            wait_for_response_id(reader: reader, id: id)
+          end
+          writer.write({ method: :exit })
+        end
+
+        def wait_for_message(reader:, unknown_messages: :ignore, &block)
+          reader.read do |message|
+            if yield(message)
+              return message
+            else
+              case unknown_messages
+              when :ignore
+                # nop
+              when :log
+                Steep.logger.error { "Unexpected message: #{message.inspect}" }
+              when :raise
+                raise "Unexpected message: #{message.inspect}"
+              end
+            end
+          end
+        end
       end
     end
   end

data/lib/steep/drivers/validate.rb

@@ -18,7 +18,7 @@ module Steep
         any_error = false
 
         project.targets.each do |target|
-          controller = Services::SignatureService.load_from(target.new_env_loader)
+          controller = Services::SignatureService.load_from(target.new_env_loader(project: project))
 
           changes = file_loader.load_changes(target.signature_pattern, changes: {})
           controller.update(changes)

data/lib/steep/drivers/watch.rb

@@ -48,13 +48,17 @@ module Steep
           interaction_worker: nil,
           typecheck_workers: typecheck_workers
         )
+        master.typecheck_automatically = false
+        master.commandline_args.push(*dirs)
 
         main_thread = Thread.start do
           master.start()
         end
         main_thread.abort_on_exception = true
 
-        client_writer.write(method: "initialize", id: 0)
+        initialize_id = request_id()
+        client_writer.write(method: "initialize", id: initialize_id)
+        wait_for_response_id(reader: client_reader, id: initialize_id)
 
         Steep.logger.info "Watching #{dirs.join(", ")}..."
 
@@ -104,10 +108,15 @@ module Steep
               end
             end
           end
+
+          client_writer.write(method: "$/typecheck", params: { guid: nil })
         end.tap(&:start)
 
         begin
           stdout.puts Rainbow("👀 Watching directories, Ctrl-C to stop.").bold
+
+          client_writer.write(method: "$/typecheck", params: { guid: nil })
+
           client_reader.read do |response|
             case response[:method]
             when "textDocument/publishDiagnostics"
@@ -121,6 +130,7 @@ module Steep
               unless diagnostics.empty?
                 diagnostics.each do |diagnostic|
                   printer.print(diagnostic)
+                  stdout.flush
                 end
               end
             when "window/showMessage"
@@ -132,16 +142,8 @@ module Steep
             end
           end
         rescue Interrupt
-          shutdown_id = -1
           stdout.puts "Shutting down workers..."
-          client_writer.write({ method: :shutdown, id: shutdown_id })
-          client_reader.read do |response|
-            if response[:id] == shutdown_id
-              break
-            end
-          end
-          client_writer.write({ method: :exit })
-          client_writer.io.close()
+          shutdown_exit(reader: client_reader, writer: client_writer)
         end
 
         listener.stop

data/lib/steep/index/signature_symbol_provider.rb

@@ -4,10 +4,14 @@ module Steep
       LSP = LanguageServer::Protocol
       SymbolInformation = Struct.new(:name, :kind, :container_name, :location, keyword_init: true)
 
+      attr_reader :project
       attr_reader :indexes
+      attr_reader :assignment
 
-      def initialize()
+      def initialize(project:, assignment:)
         @indexes = []
+        @project = project
+        @assignment = assignment
       end
 
       def self.test_type_name(query, type_name)
@@ -33,7 +37,17 @@ module Steep
         end
       end
 
-      def query_symbol(query, assignment:)
+      def assigned?(path)
+        if path.relative?
+          if project.targets.any? {|target| target.possible_signature_file?(path) }
+            path = project.absolute_path(path)
+          end
+        end
+
+        assignment =~ path
+      end
+
+      def query_symbol(query)
         symbols = []
 
         indexes.each do |index|
@@ -46,7 +60,7 @@ module Steep
               name = entry.type_name.name.to_s
 
               entry.declarations.each do |decl|
-                next unless assignment =~ decl.location.buffer.name
+                next unless assigned?(Pathname(decl.location.buffer.name))
 
                 case decl
                 when RBS::AST::Declarations::Class
@@ -91,7 +105,7 @@ module Steep
               container_name = entry.method_name.type_name.relative!.to_s
 
               entry.declarations.each do |decl|
-                next unless assignment =~ decl.location.buffer.name
+                next unless assigned?(Pathname(decl.location.buffer.name))
 
                 case decl
                 when RBS::AST::Members::MethodDefinition
@@ -130,7 +144,7 @@ module Steep
               next unless SignatureSymbolProvider.test_const_name(query, entry.const_name)
 
               entry.declarations.each do |decl|
-                next unless assignment =~ decl.location.buffer.name
+                next unless assigned?(Pathname(decl.location.buffer.name))
 
                 symbols << SymbolInformation.new(
                   name: entry.const_name.name.to_s,
@@ -143,7 +157,7 @@ module Steep
               next unless SignatureSymbolProvider.test_global_name(query, entry.global_name)
 
               entry.declarations.each do |decl|
-                next unless assignment =~ decl.location.buffer.name
+                next unless assigned?(Pathname(decl.location.buffer.name))
 
                 symbols << SymbolInformation.new(
                   name: decl.name.to_s,

data/lib/steep/project/target.rb

@@ -25,14 +25,14 @@ module Steep
         signature_pattern =~ path
       end
 
-      def new_env_loader
-        Target.construct_env_loader(options: options)
+      def new_env_loader(project:)
+        Target.construct_env_loader(options: options, project: project)
       end
 
-      def self.construct_env_loader(options:)
+      def self.construct_env_loader(options:, project:)
         repo = RBS::Repository.new(no_stdlib: options.vendor_path)
         options.repository_paths.each do |path|
-          repo.add(path)
+          repo.add(project.absolute_path(path))
         end
 
         loader = RBS::EnvironmentLoader.new(

data/lib/steep/server/interaction_worker.rb

@@ -12,8 +12,7 @@ module Steep
       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!
+        @service = Services::TypeCheckService.new(project: project)
         @mutex = Mutex.new
         @buffered_changes = {}
       end
@@ -24,7 +23,7 @@ module Steep
 
           unless changes.empty?
             Steep.logger.debug { "Applying changes for #{changes.size} files..." }
-            service.update(changes: changes) {}
+            service.update(changes: changes)
           end
 
           case job

data/lib/steep/server/master.rb

@@ -3,109 +3,372 @@ module Steep
     class Master
       LSP = LanguageServer::Protocol
 
-      attr_reader :steepfile
-      attr_reader :project
-      attr_reader :reader, :writer
+      class TypeCheckRequest
+        attr_reader :guid
+        attr_reader :library_paths
+        attr_reader :signature_paths
+        attr_reader :code_paths
+        attr_reader :priority_paths
+        attr_reader :checked_paths
+
+        def initialize(guid:)
+          @guid = guid
+          @library_paths = Set[]
+          @signature_paths = Set[]
+          @code_paths = Set[]
+          @priority_paths = Set[]
+          @checked_paths = Set[]
+        end
 
-      attr_reader :interaction_worker
-      attr_reader :typecheck_workers
+        def uri(path)
+          URI.parse(path.to_s).tap do |uri|
+            uri.scheme = "file"
+          end
+        end
 
-      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
+        def as_json(assignment:)
+          {
+            guid: guid,
+            library_uris: library_paths.grep(assignment).map {|path| uri(path).to_s },
+            signature_uris: signature_paths.grep(assignment).map {|path| uri(path).to_s },
+            code_uris: code_paths.grep(assignment).map {|path| uri(path).to_s },
+            priority_uris: priority_paths.map {|path| uri(path).to_s }
+          }
+        end
 
-        attr_reader :request
-        attr_reader :responses
+        def total
+          library_paths.size + signature_paths.size + code_paths.size
+        end
 
-        attr_reader :on_response_handlers
-        attr_reader :on_completion_handlers
+        def percentage
+          checked_paths.size * 100 / total
+        end
 
-        def initialize(request:, workers:)
-          @workers = []
+        def all_paths
+          library_paths + signature_paths + code_paths
+        end
 
-          @request = request
-          @responses = workers.each.with_object({}) do |worker, hash|
-            hash[worker] = nil
+        def checking_path?(path)
+          library_paths.include?(path) ||
+            signature_paths.include?(path) ||
+            code_paths.include?(path)
+        end
+
+        def checked(path)
+          raise unless checking_path?(path)
+          checked_paths << path
+        end
+
+        def finished?
+          unchecked_paths.empty?
+        end
+
+        def unchecked_paths
+          all_paths - checked_paths
+        end
+
+        def unchecked_code_paths
+          code_paths - checked_paths
+        end
+
+        def unchecked_library_paths
+          library_paths - checked_paths
+        end
+
+        def unchecked_signature_paths
+          signature_paths - checked_paths
+        end
+      end
+
+      class TypeCheckController
+        attr_reader :project
+        attr_reader :priority_paths
+        attr_reader :changed_paths
+        attr_reader :target_paths
+
+        class TargetPaths
+          attr_reader :project
+          attr_reader :target
+          attr_reader :code_paths
+          attr_reader :signature_paths
+          attr_reader :library_paths
+
+          def initialize(project:, target:)
+            @project = project
+            @target = target
+            @code_paths = Set[]
+            @signature_paths = Set[]
+            @library_paths = Set[]
           end
 
-          @on_response_handlers = []
-          @on_completion_handlers = []
+          def all_paths
+            code_paths + signature_paths + library_paths
+          end
+
+          def library_path?(path)
+            library_paths.include?(path)
+          end
+
+          def signature_path?(path)
+            signature_paths.include?(path)
+          end
+
+          def code_path?(path)
+            code_paths.include?(path)
+          end
+
+          def add(path)
+            return if library_path?(path) || signature_path?(path) || code_path?(path)
+
+            relative_path = project.relative_path(path)
+
+            case
+            when target.source_pattern =~ relative_path
+              code_paths << path
+            when target.signature_pattern =~ relative_path
+              signature_paths << path
+            else
+              library_paths << path
+            end
+          end
+
+          alias << add
         end
 
-        def on_response(&block)
-          on_response_handlers << block
+        def initialize(project:)
+          @project = project
+          @priority_paths = Set[]
+          @changed_paths = Set[]
+          @target_paths = project.targets.each.map {|target| TargetPaths.new(project: project, target: target) }
         end
 
-        def on_completion(&block)
-          on_completion_handlers << block
+        def load(command_line_args:)
+          loader = Services::FileLoader.new(base_dir: project.base_dir)
+
+          target_paths.each do |paths|
+            target = paths.target
+
+            signature_service = Services::SignatureService.load_from(target.new_env_loader(project: project))
+            paths.library_paths.merge(signature_service.env_rbs_paths)
+
+            loader.each_path_in_patterns(target.source_pattern, command_line_args) do |path|
+              paths.code_paths << project.absolute_path(path)
+            end
+            loader.each_path_in_patterns(target.signature_pattern) do |path|
+              paths.signature_paths << project.absolute_path(path)
+            end
+
+            changed_paths.merge(paths.all_paths)
+          end
         end
 
-        def request_id
-          request[:id]
+        def push_changes(path)
+          return if target_paths.any? {|paths| paths.library_path?(path) }
+
+          target_paths.each {|paths| paths << path }
+
+          if target_paths.any? {|paths| paths.code_path?(path) || paths.signature_path?(path) }
+            changed_paths << path
+          end
         end
 
-        def process_response(response, worker)
-          responses[worker] = response
+        def update_priority(open: nil, close: nil)
+          path = open || close
+
+          target_paths.each {|paths| paths << path }
 
-          on_response_handlers.each do |handler|
-            handler[worker, response]
+          case
+          when open
+            priority_paths << path
+          when close
+            priority_paths.delete path
           end
+        end
+
+        def make_request(guid: SecureRandom.uuid, last_request: nil, include_unchanged: false)
+          return if changed_paths.empty? && !include_unchanged
+
+          TypeCheckRequest.new(guid: guid).tap do |request|
+            if last_request
+              request.library_paths.merge(last_request.unchecked_library_paths)
+              request.signature_paths.merge(last_request.unchecked_signature_paths)
+              request.code_paths.merge(last_request.unchecked_code_paths)
+            end
+
+            if include_unchanged
+              target_paths.each do |paths|
+                request.signature_paths.merge(paths.signature_paths)
+                request.library_paths.merge(paths.library_paths)
+                request.code_paths.merge(paths.code_paths)
+              end
+            else
+              updated_paths = target_paths.select {|paths| changed_paths.intersect?(paths.all_paths) }
+
+              updated_paths.each do |paths|
+                case
+                when paths.signature_paths.intersect?(changed_paths)
+                  request.signature_paths.merge(paths.signature_paths)
+                  request.library_paths.merge(paths.library_paths)
+                  request.code_paths.merge(paths.code_paths)
+                when paths.code_paths.intersect?(changed_paths)
+                  request.code_paths.merge(paths.code_paths & changed_paths)
+                end
+              end
+            end
+
+            request.priority_paths.merge(priority_paths)
+
+            changed_paths.clear()
+          end
+        end
+      end
+
+      class ResultHandler
+        attr_reader :request
+        attr_reader :completion_handler
+        attr_reader :response
+
+        def initialize(request:)
+          @request = request
+          @response = nil
+          @completion_handler = nil
+          @completed = false
+        end
+
+        def process_response(message)
+          if request[:id] == message[:id]
+            completion_handler&.call(message)
+            @response = message
+            true
+          else
+            false
+          end
+        end
 
-          if completed?
-            on_completion_handlers.each do |handler|
-              handler[*responses.values]
+        def result
+          response&.dig(:result)
+        end
+
+        def completed?
+          !!@response
+        end
+
+        def on_completion(&block)
+          @completion_handler = block
+        end
+      end
+
+      class GroupHandler
+        attr_reader :request
+        attr_reader :handlers
+        attr_reader :completion_handler
+
+        def initialize()
+          @handlers = {}
+          @waiting_handlers = Set[]
+          @completion_handler = nil
+        end
+
+        def process_response(message)
+          if handler = handlers[message[:id]]
+            handler.process_response(message)
+
+            if completed?
+              completion_handler&.call(handlers.values)
             end
+
+            true
+          else
+            false
           end
         end
 
         def completed?
-          responses.each_value.none?(&:nil?)
+          handlers.each_value.all? {|handler| handler.completed? }
+        end
+
+        def <<(handler)
+          handlers[handler.request[:id]] = handler
+        end
+
+        def on_completion(&block)
+          @completion_handler = block
+        end
+      end
+
+      class ResultController
+        attr_reader :handlers
+
+        def initialize()
+          @handlers = []
+        end
+
+        def <<(handler)
+          @handlers << handler
+        end
+
+        def request_group()
+          group = GroupHandler.new()
+          yield group
+          group
+        end
+
+        def process_response(message)
+          handlers.each do |handler|
+            return true if handler.process_response(message)
+          end
+          false
+        ensure
+          handlers.reject!(&:completed?)
         end
       end
 
+      ReceiveMessageJob = Struct.new(:source, :message, keyword_init: true) do
+        def response?
+          message.key?(:id) && !message.key?(:method)
+        end
+      end
+
+      SendMessageJob = Struct.new(:dest, :message, keyword_init: true) do
+        def self.to_worker(worker, message:)
+          new(dest: worker, message: message)
+        end
+
+        def self.to_client(message:)
+          new(dest: :client, message: message)
+        end
+      end
+
+      attr_reader :steepfile
+      attr_reader :project
+      attr_reader :reader, :writer
+      attr_reader :commandline_args
+
+      attr_reader :interaction_worker
+      attr_reader :typecheck_workers
+
+      attr_reader :job_queue
+
+      attr_reader :current_type_check_request
+      attr_reader :controller
+      attr_reader :result_controller
+
+      attr_reader :initialize_params
+      attr_accessor :typecheck_automatically
+
       def initialize(project:, reader:, writer:, interaction_worker:, typecheck_workers:, queue: Queue.new)
         @project = project
         @reader = reader
         @writer = writer
-        @write_queue = queue
-        @recon_queue = Queue.new
         @interaction_worker = interaction_worker
         @typecheck_workers = typecheck_workers
-        @shutdown_request_id = nil
-        @response_handlers = {}
+        @current_type_check_request = nil
+        @typecheck_automatically = true
+        @commandline_args = []
+        @job_queue = queue
+
+        @controller = TypeCheckController.new(project: project)
+        @result_controller = ResultController.new()
       end
 
       def start
@@ -118,7 +381,7 @@ module Steep
             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)
+                job_queue << ReceiveMessageJob.new(source: interaction_worker, message: message)
               end
             end
           end
@@ -127,42 +390,57 @@ module Steep
             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)
+                job_queue << ReceiveMessageJob.new(source: worker, message: message)
               end
             end
           end
 
-          worker_threads << Thread.new do
-            Steep.logger.formatter.push_tags(*tags, "write")
-            while message = write_queue.pop
-              writer.write(message)
-            end
-
-            writer.io.close
-          end
-
-          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
+          read_client_thread = Thread.new do
+            reader.read do |message|
+              job_queue << ReceiveMessageJob.new(source: :client, message: message)
+              break if message[:method] == "exit"
             end
           end
 
           Steep.logger.tagged "main" do
-            reader.read do |request|
-              process_message_from_client(request) or break
+            while job = job_queue.deq
+              case job
+              when ReceiveMessageJob
+                src = if job.source == :client
+                        :client
+                      else
+                        job.source.name
+                      end
+                Steep.logger.tagged("ReceiveMessageJob(#{src}/#{job.message[:method]}/#{job.message[:id]})") do
+                  if job.response? && result_controller.process_response(job.message)
+                    # nop
+                    Steep.logger.info { "Processed by ResultController" }
+                  else
+                    case job.source
+                    when :client
+                      process_message_from_client(job.message)
+
+                      if job.message[:method] == "exit"
+                        job_queue.close()
+                      end
+                    when WorkerProcess
+                      process_message_from_worker(job.message, worker: job.source)
+                    end
+                  end
+                end
+              when SendMessageJob
+                case job.dest
+                when :client
+                  Steep.logger.info { "Processing SendMessageJob: dest=client, method=#{job.message[:method] || "-"}, id=#{job.message[:id] || "-"}" }
+                  writer.write job.message
+                when WorkerProcess
+                  Steep.logger.info { "Processing SendMessageJob: dest=#{job.dest.name}, method=#{job.message[:method] || "-"}, id=#{job.message[:id] || "-"}" }
+                  job.dest << job.message
+                end
+              end
             end
 
+            read_client_thread.join()
             worker_threads.each do |thread|
               thread.join
             end
@@ -179,138 +457,311 @@ module Steep
         end
       end
 
+      def pathname(uri)
+        Pathname(URI.parse(uri).path)
+      end
+
+      def work_done_progress_supported?
+        initialize_params&.dig(:capabilities, :window, :workDoneProgress)
+      end
+
       def process_message_from_client(message)
-        Steep.logger.info "Received message #{message[:method]}(#{message[:id]})"
+        Steep.logger.info "Processing message from client: method=#{message[:method]}, id=#{message[:id]}"
         id = message[:id]
 
         case message[:method]
         when "initialize"
-          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
+          @initialize_params = message[:params]
+          result_controller << group_request do |group|
+            each_worker do |worker|
+              group << send_request(method: "initialize", params: message[:params], worker: worker)
+            end
+
+            group.on_completion do
+              controller.load(command_line_args: commandline_args)
+
+              job_queue << SendMessageJob.to_client(
+                message: {
+                  id: id,
+                  result: LSP::Interface::InitializeResult.new(
+                    capabilities: LSP::Interface::ServerCapabilities.new(
+                      text_document_sync: LSP::Interface::TextDocumentSyncOptions.new(
+                        change: LSP::Constant::TextDocumentSyncKind::INCREMENTAL,
+                        save: LSP::Interface::SaveOptions.new(include_text: false),
+                        open_close: true
+                      ),
+                      hover_provider: {
+                        workDoneProgress: true,
+                        partialResults: true,
+                        partialResult: true
+                      },
+                      completion_provider: LSP::Interface::CompletionOptions.new(
+                        trigger_characters: [".", "@"],
+                        work_done_progress: true
+                      ),
+                      workspace_symbol_provider: true
+                    )
                   )
-                )
-              }
+                }
+              )
             end
           end
 
+        when "initialized"
+          if typecheck_automatically
+            request = controller.make_request(include_unchanged: true)
+            start_type_check(request, last_request: nil, start_progress: request.total > 10)
+          end
+
         when "textDocument/didChange"
           broadcast_notification(message)
+          path = pathname(message[:params][:textDocument][:uri])
+          controller.push_changes(path)
+
+        when "textDocument/didSave"
+          if typecheck_automatically
+            request = controller.make_request(last_request: current_type_check_request)
+            start_type_check(
+              request,
+              last_request: current_type_check_request,
+              start_progress: request.total > 10
+            )
+          end
+
+        when "textDocument/didOpen"
+          path = pathname(message[:params][:textDocument][:uri])
+          controller.update_priority(open: path)
+
+        when "textDocument/didClose"
+          path = pathname(message[:params][:textDocument][:uri])
+          controller.update_priority(close: path)
 
         when "textDocument/hover", "textDocument/completion"
           if interaction_worker
-            send_request(message, worker: interaction_worker) do |handler|
+            result_controller << send_request(method: message[:method], params: message[:params], worker: interaction_worker) do |handler|
               handler.on_completion do |response|
-                write_queue << response
+                job_queue << SendMessageJob.to_client(
+                  message: {
+                    id: message[:id],
+                    result: response[:result]
+                  }
+                )
               end
             end
           end
 
-        when "textDocument/open"
-          # Ignores open notification
-
         when "workspace/symbol"
-          send_request(message, workers: typecheck_workers) do |handler|
-            handler.on_completion do |*responses|
-              result = responses.flat_map {|resp| resp[:result] || [] }
+          result_controller << group_request do |group|
+            typecheck_workers.each do |worker|
+              group << send_request(method: "workspace/symbol", params: message[:params], worker: worker)
+            end
 
-              write_queue << {
-                id: handler.request_id,
-                result: result
-              }
+            group.on_completion do |handlers|
+              result = handlers.flat_map(&:result)
+              job_queue << SendMessageJob.to_client(message: { id: message[:id], result: result })
             end
           end
 
         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
-                }
+            result_controller << group_request do |group|
+              typecheck_workers.each do |worker|
+                group << send_request(method: "workspace/executeCommand", params: message[:params], worker: worker)
+              end
+
+              group.on_completion do |handlers|
+                stats = handlers.flat_map(&:result)
+                job_queue << SendMessageJob.to_client(
+                  message: {
+                    id: message[:id],
+                    result: stats
+                  }
+                )
               end
             end
           end
 
+        when "$/typecheck"
+          request = controller.make_request(
+            guid: message[:params][:guid],
+            last_request: current_type_check_request,
+            include_unchanged: true
+          )
+          start_type_check(
+            request,
+            last_request: current_type_check_request,
+            start_progress: true
+          )
+
         when "shutdown"
-          broadcast_request(message) do |handler|
-            handler.on_completion do |*_|
-              write_queue << { id: id, result: nil}
+          result_controller << group_request do |group|
+            each_worker do |worker|
+              group << send_request(method: "shutdown", worker: worker)
+            end
 
-              write_queue.close
-              recon_queue.close
+            group.on_completion do
+              job_queue << SendMessageJob.to_client(message: { id: message[:id], result: nil })
             end
           end
 
         when "exit"
           broadcast_notification(message)
+        end
+      end
+
+      def process_message_from_worker(message, worker:)
+        Steep.logger.tagged "#process_message_from_worker (worker=#{worker.name})" do
+          Steep.logger.info { "Processing message from worker: method=#{message[:method] || "-"}, id=#{message[:id] || "*"}" }
+
+          case
+          when message.key?(:id) && !message.key?(:method)
+            Steep.logger.tagged "response(id=#{message[:id]})" do
+              Steep.logger.error { "Received unexpected response" }
+              Steep.logger.debug { "result = #{message[:result].inspect}" }
+            end
+          when message.key?(:method) && !message.key?(:id)
+            case message[:method]
+            when "$/typecheck/progress"
+              on_type_check_update(
+                guid: message[:params][:guid],
+                path: Pathname(message[:params][:path])
+              )
+            else
+              # Forward other notifications
+              job_queue << SendMessageJob.to_client(message: message)
+            end
+          end
+        end
+      end
+
+      def start_type_check(request, last_request:, start_progress:)
+        Steep.logger.tagged "#start_type_check(#{request.guid}, #{last_request&.guid}" do
+          unless request
+            Steep.logger.info "Skip start type checking"
+            return
+          end
+
+          if last_request
+            Steep.logger.info "Cancelling last request"
+
+            job_queue << SendMessageJob.to_client(
+              message: {
+                method: "$/progress",
+                params: {
+                  token: last_request.guid,
+                  value: { kind: "end" }
+                }
+              }
+            )
+          end
+
+          if start_progress
+            Steep.logger.info "Starting new progress..."
 
-          return false
+            @current_type_check_request = request
+
+            if work_done_progress_supported?
+              job_queue << SendMessageJob.to_client(
+                message: {
+                  id: fresh_request_id,
+                  method: "window/workDoneProgress/create",
+                  params: { token: request.guid }
+                }
+              )
+            end
+
+            job_queue << SendMessageJob.to_client(
+              message: {
+                method: "$/progress",
+                params: {
+                  token: request.guid,
+                  value: { kind: "begin", title: "Type checking", percentage: 0 }
+                }
+              }
+            )
+
+            if request.finished?
+              job_queue << SendMessageJob.to_client(
+                message: {
+                  method: "$/progress",
+                  params: { token: request.guid, value: { kind: "end" } }
+                }
+              )
+            end
+          else
+            @current_type_check_request = nil
+          end
+
+          Steep.logger.info "Sending $/typecheck/start notifications"
+          typecheck_workers.each do |worker|
+            assignment = Services::PathAssignment.new(max_index: typecheck_workers.size, index: worker.index)
+
+            job_queue << SendMessageJob.to_worker(
+              worker,
+              message: {
+                method: "$/typecheck/start",
+                params: request.as_json(assignment: assignment)
+              }
+            )
+          end
         end
+      end
 
-        true
+      def on_type_check_update(guid:, path:)
+        if current = current_type_check_request()
+          if current.guid == guid
+            current.checked(path)
+            Steep.logger.info { "Request updated: checked=#{path}, unchecked=#{current.unchecked_paths.size}" }
+            percentage = current.percentage
+            value = if percentage == 100
+                      { kind: "end" }
+                    else
+                      progress_string = ("▮"*(percentage/5)) + ("▯"*(20 - percentage/5))
+                      { kind: "report", percentage: percentage, message: "#{progress_string} (#{percentage}%)" }
+                    end
+
+            job_queue << SendMessageJob.to_client(
+              message: {
+                method: "$/progress",
+                params: { token: current.guid, value: value }
+              }
+            )
+
+            @current_type_check_request = nil if current.finished?
+          end
+        end
       end
 
       def broadcast_notification(message)
         Steep.logger.info "Broadcasting notification #{message[:method]}"
         each_worker do |worker|
-          worker << message
+          job_queue << SendMessageJob.new(dest: worker, message: message)
         end
       end
 
       def send_notification(message, worker:)
         Steep.logger.info "Sending notification #{message[:method]} to #{worker.name}"
-        worker << message
+        job_queue << SendMessageJob.new(dest: worker, message: message)
       end
 
-      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
+      def fresh_request_id
+        SecureRandom.alphanumeric(10)
       end
 
-      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
+      def send_request(method:, id: fresh_request_id(), params: nil, worker:, &block)
+        Steep.logger.info "Sending request #{method}(#{id}) to #{worker.name}"
 
-        each_worker do |worker|
-          worker << message
+        message = { method: method, id: id, params: params }
+        ResultHandler.new(request: message).tap do |handler|
+          yield handler if block_given?
+          job_queue << SendMessageJob.to_worker(worker, message: message)
         end
       end
 
-      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
+      def group_request()
+        GroupHandler.new().tap do |group|
+          yield group
         end
       end