steep 0.40.0 → 0.44.0

data/lib/steep/server/base_worker.rb

@@ -3,10 +3,8 @@ 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)
 

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,39 +1,62 @@
 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)
+        @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]
@@ -42,22 +65,19 @@ module Steep
           uri = URI.parse(params[:textDocument][:uri])
           path = project.relative_path(Pathname(uri.path))
           line, column = params[:position].yield_self {|hash| [hash[:line]+1, hash[:character]] }
-          trigger = params[:context][:triggerCharacter]
+          trigger = params.dig(: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 }
@@ -70,22 +90,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
@@ -107,7 +127,7 @@ HOVER
           else
             "`#{content.type}`"
           end
-        when Project::HoverContent::DefinitionContent
+        when Services::HoverContent::DefinitionContent
           string = <<HOVER
 ```
 def #{content.method_name}: #{content.method_type}
@@ -122,42 +142,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
@@ -175,7 +190,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,
@@ -185,7 +200,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(
@@ -199,7 +214,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

@@ -3,185 +3,444 @@ module Steep
     class Master
       LSP = LanguageServer::Protocol
 
-      attr_reader :steepfile
-      attr_reader :project
-      attr_reader :reader, :writer
-      attr_reader :worker_count
-      attr_reader :worker_to_paths
+      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 :signature_worker
-      attr_reader :code_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
-
-      include Utils
-
-      class ResponseHandler
-        attr_reader :workers
+        def uri(path)
+          URI.parse(path.to_s).tap do |uri|
+            uri.scheme = "file"
+          end
+        end
 
-        attr_reader :request
-        attr_reader :responses
+        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 :on_response_handlers
-        attr_reader :on_completion_handlers
+        def total
+          library_paths.size + signature_paths.size + code_paths.size
+        end
 
-        def initialize(request:, workers:)
-          @workers = []
+        def percentage
+          checked_paths.size * 100 / total
+        end
 
-          @request = request
-          @responses = workers.each.with_object({}) do |worker, hash|
-            hash[worker] = nil
+        def all_paths
+          library_paths + signature_paths + code_paths
+        end
+
+        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
+
+          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
 
-          @on_response_handlers = []
-          @on_completion_handlers = []
+          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
 
-          on_response_handlers.each do |handler|
-            handler[worker, response]
+          target_paths.each {|paths| paths << path }
+
+          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
 
-          if completed?
-            on_completion_handlers.each do |handler|
-              handler[*responses.values]
+          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
+
+        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
 
-      def initialize(project:, reader:, writer:, interaction_worker:, signature_worker:, code_workers:, queue: Queue.new)
+      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
-        @signature_worker = signature_worker
-        @code_workers = code_workers
-        @worker_to_paths = {}
-        @shutdown_request_id = nil
-        @response_handlers = {}
+        @typecheck_workers = typecheck_workers
+        @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
         Steep.logger.tagged "master" do
           tags = Steep.logger.formatter.current_tags.dup
 
-          Steep.logger.info "Registering all code to workers..."
-          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
-
           worker_threads = []
 
-          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
-
-          worker_threads << Thread.new do
-            Steep.logger.formatter.push_tags(*tags, "from-worker@signature")
-            signature_worker.reader.read do |message|
-              process_message_from_worker(message, worker: signature_worker)
+          if interaction_worker
+            worker_threads << Thread.new do
+              Steep.logger.formatter.push_tags(*tags, "from-worker@interaction")
+              interaction_worker.reader.read do |message|
+                job_queue << ReceiveMessageJob.new(source: interaction_worker, message: message)
+              end
             end
           end
 
-          code_workers.each do |worker|
+          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)
+                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
@@ -191,181 +450,340 @@ module Steep
 
       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 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,
+                      definition_provider: true,
+                      declaration_provider: true,
+                      implementation_provider: true,
+                      type_definition_provider: true
+                    )
                   )
-                )
-              }
+                }
+              )
             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()
+        when "initialized"
+          if typecheck_automatically
+            if request = controller.make_request(include_unchanged: true)
+              start_type_check(request, last_request: nil, start_progress: request.total > 10)
+            end
           end
 
+        when "textDocument/didChange"
           broadcast_notification(message)
+          path = pathname(message[:params][:textDocument][:uri])
+          controller.push_changes(path)
+
+        when "textDocument/didSave"
+          if typecheck_automatically
+            if 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
+          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"
-          send_request(message, worker: interaction_worker) do |handler|
-            handler.on_completion do |response|
-              write_queue << response
+          if interaction_worker
+            result_controller << send_request(method: message[:method], params: message[:params], worker: interaction_worker) do |handler|
+              handler.on_completion do |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, worker: signature_worker) do |handler|
-            handler.on_completion do |response|
-              write_queue << response
+          result_controller << group_request do |group|
+            typecheck_workers.each do |worker|
+              group << send_request(method: "workspace/symbol", params: message[:params], worker: worker)
+            end
+
+            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: code_workers) do |handler|
-              handler.on_completion do |*responses|
-                stats = responses.flat_map {|resp| resp[:result] }
+            result_controller << group_request do |group|
+              typecheck_workers.each do |worker|
+                group << send_request(method: "workspace/executeCommand", params: message[:params], worker: worker)
+              end
 
-                write_queue << {
-                  id: handler.request_id,
-                  result: stats
-                }
+              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 "textDocument/definition", "textDocument/implementation"
+          result_controller << group_request do |group|
+            typecheck_workers.each do |worker|
+              group << send_request(method: message[:method], params: message[:params], worker: worker)
+            end
+
+            group.on_completion do |handlers|
+              links = handlers.flat_map(&:result)
+              job_queue << SendMessageJob.to_client(
+                message: {
+                  id: message[:id],
+                  result: links
+                }
+              )
+            end
+          end
+
+        when "$/typecheck"
+          request = controller.make_request(
+            guid: message[:params][:guid],
+            last_request: current_type_check_request,
+            include_unchanged: true
+          )
+
+          if request
+            start_type_check(
+              request,
+              last_request: current_type_check_request,
+              start_progress: true
+            )
+          end
+
         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)
-
-          return false
         end
-
-        true
       end
 
-      def broadcast_notification(message)
-        Steep.logger.info "Broadcasting notification #{message[:method]}"
-        each_worker do |worker|
-          worker << message
+      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 send_notification(message, worker:)
-        Steep.logger.info "Sending notification #{message[:method]} to #{worker.name}"
-        worker << message
-      end
+      def start_type_check(request, last_request:, start_progress:)
+        Steep.logger.tagged "#start_type_check(#{request.guid}, #{last_request&.guid}" do
+          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..."
+
+            @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
 
-      def send_request(message, worker: nil, workers: [])
-        workers << worker if worker
+            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 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
+          Steep.logger.info "Sending $/typecheck/start notifications"
+          typecheck_workers.each do |worker|
+            assignment = Services::PathAssignment.new(max_index: typecheck_workers.size, index: worker.index)
 
-        workers.each do |w|
-          w << message
+            job_queue << SendMessageJob.to_worker(
+              worker,
+              message: {
+                method: "$/typecheck/start",
+                params: request.as_json(assignment: assignment)
+              }
+            )
+          end
         end
       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 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 }
+              }
+            )
 
-        each_worker do |worker|
-          worker << message
+            @current_type_check_request = nil if current.finished?
+          end
         end
       end
 
-      def process_message_from_worker(message, worker:)
-        case
-        when message.key?(:id) && !message.key?(:method)
-          # Response from worker
-          Steep.logger.info "Received response #{message[:id]} from worker"
-          recon_queue << [message, worker]
-        when message.key?(:method) && !message.key?(:id)
-          # Notification from worker
-          Steep.logger.info "Received notification #{message[:method]} from worker"
-          write_queue << message
+      def broadcast_notification(message)
+        Steep.logger.info "Broadcasting notification #{message[:method]}"
+        each_worker do |worker|
+          job_queue << SendMessageJob.new(dest: worker, message: 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}"
+        job_queue << SendMessageJob.new(dest: worker, message: message)
       end
 
-      def least_busy_worker
-        code_workers.min_by do |w|
-          paths_for(w).size
-        end
+      def fresh_request_id
+        SecureRandom.alphanumeric(10)
       end
 
-      def registered_path?(path)
-        worker_to_paths.each_value.any? {|set| set.include?(path) }
-      end
+      def send_request(method:, id: fresh_request_id(), params: nil, worker:, &block)
+        Steep.logger.info "Sending request #{method}(#{id}) to #{worker.name}"
 
-      def register_code_to_worker(paths, worker:)
-        paths_for(worker).merge(paths)
+        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
 
-        send_notification(
-          {
-            method: "workspace/executeCommand",
-            params: LSP::Interface::ExecuteCommandParams.new(
-              command: "steep/registerSourceToWorker",
-              arguments: paths.map do |path|
-                "file://#{project.absolute_path(path)}"
-              end
-            )
-          },
-          worker: worker
-        )
+      def group_request()
+        GroupHandler.new().tap do |group|
+          yield group
+        end
       end
 
       def kill