steep 0.39.0 → 0.40.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

@@ -8,13 +8,28 @@ module Steep
       attr_reader :project
       attr_reader :reader, :writer
 
+      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 +44,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 +74,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 +87,6 @@ module Steep
               end
             end
           ensure
-            queue << nil
             thread.join
           end
         end

data/lib/steep/server/code_worker.rb

@@ -3,6 +3,9 @@ module Steep
     class CodeWorker < BaseWorker
       LSP = LanguageServer::Protocol
 
+      TypeCheckJob = Struct.new(:target, :path, keyword_init: true)
+      StatsJob = Struct.new(:request, :paths, keyword_init: true)
+
       include Utils
 
       attr_reader :typecheck_paths
@@ -17,7 +20,7 @@ module Steep
 
       def enqueue_type_check(target:, path:)
         Steep.logger.info "Enqueueing type check: #{target.name}::#{path}..."
-        queue << [target, path]
+        queue << TypeCheckJob.new(target: target, path: path)
       end
 
       def typecheck_file(path, target)
@@ -43,6 +46,23 @@ module Steep
         )
       end
 
+      def calculate_stats(request_id, paths)
+        calculator = Project::StatsCalculator.new(project: project)
+
+        stats = paths.map do |path|
+          if typecheck_paths.include?(path)
+            if target = project.target_for_source_path(path)
+              calculator.calc_stats(target, path)
+            end
+          end
+        end.compact
+
+        writer.write(
+          id: request_id,
+          result: stats.map(&:as_json)
+        )
+      end
+
       def source_diagnostics(source, options)
         case status = source.status
         when Project::SourceFile::ParseErrorStatus
@@ -65,24 +85,8 @@ module Steep
             )
           ]
         when Project::SourceFile::TypeCheckStatus
-          status.typing.errors.select {|error| options.error_to_report?(error) }.map do |error|
-            loc = error.location_to_str
-
-            LSP::Interface::Diagnostic.new(
-              message: StringIO.new.tap {|io| error.print_to(io) }.string.gsub(/\A#{Regexp.escape(loc)}: /, "").chomp,
-              severity: LSP::Constant::DiagnosticSeverity::ERROR,
-              range: LSP::Interface::Range.new(
-                start: LSP::Interface::Position.new(
-                  line: error.node.loc.line - 1,
-                  character: error.node.loc.column
-                ),
-                end: LSP::Interface::Position.new(
-                  line: error.node.loc.last_line - 1,
-                  character: error.node.loc.last_column
-                )
-              )
-            )
-          end
+          formatter = Diagnostic::LSPFormatter.new()
+          status.typing.errors.select {|error| options.error_to_report?(error) }.map {|error| formatter.format(error) }
         when Project::SourceFile::TypeCheckErrorStatus
           []
         end
@@ -91,7 +95,6 @@ module Steep
       def handle_request(request)
         case request[:method]
         when "initialize"
-          # Don't respond to initialize request, but start type checking.
           project.targets.each do |target|
             target.source_files.each_key do |path|
               if typecheck_paths.include?(path)
@@ -100,10 +103,17 @@ module Steep
             end
           end
 
+          writer.write({ id: request[:id], result: nil })
+
         when "workspace/executeCommand"
-          if request[:params][:command] == "steep/registerSourceToWorker"
+          Steep.logger.info { "Executing command: #{request[:params][:command]}, arguments=#{request[:params][:arguments].map(&:inspect).join(", ")}" }
+          case request[:params][:command]
+          when "steep/registerSourceToWorker"
             paths = request[:params][:arguments].map {|arg| source_path(URI.parse(arg)) }
             typecheck_paths.merge(paths)
+          when "steep/stats"
+            paths = request[:params][:arguments].map {|arg| source_path(URI.parse(arg)) }
+            queue << StatsJob.new(paths: paths, request: request)
           end
 
         when "textDocument/didChange"
@@ -128,9 +138,12 @@ module Steep
       end
 
       def handle_job(job)
-        target, path = job
-
-        typecheck_file(path, target)
+        case job
+        when TypeCheckJob
+          typecheck_file(job.path, job.target)
+        when StatsJob
+          calculate_stats(job.request[:id], job.paths)
+        end
       end
     end
   end

data/lib/steep/server/interaction_worker.rb

@@ -17,6 +17,7 @@ module Steep
         case request[:method]
         when "initialize"
           # nop
+          writer.write({ id: request[:id], result: nil })
 
         when "textDocument/didChange"
           update_source(request)

data/lib/steep/server/master.rb

@@ -6,7 +6,6 @@ module Steep
       attr_reader :steepfile
       attr_reader :project
       attr_reader :reader, :writer
-      attr_reader :queue
       attr_reader :worker_count
       attr_reader :worker_to_paths
 
@@ -14,75 +13,179 @@ module Steep
       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
+
+        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
+
+          if completed?
+            on_completion_handlers.each do |handler|
+              handler[*responses.values]
+            end
+          end
+        end
+
+        def completed?
+          responses.each_value.none?(&:nil?)
+        end
+      end
+
       def initialize(project:, reader:, writer:, interaction_worker:, signature_worker:, code_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 = {}
         @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
+
+          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
 
-        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)
+          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
 
-        Thread.new do
-          Steep.logger.formatter.push_tags(*tags, "from-worker@signature")
-          signature_worker.reader.read do |message|
-            process_message_from_worker(message)
+          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)
+            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)
+          code_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
 
-        Thread.new do
-          Steep.logger.formatter.push_tags(*tags, "from-client")
-          reader.read do |request|
-            process_message_from_client(request)
+          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
-        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
 
@@ -97,28 +200,29 @@ module Steep
       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: [".", "@"]
-                ),
-                workspace_symbol_provider: true
-              )
-            )
-          }
-
-          each_worker do |worker|
-            worker << message
+          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
+                  )
+                )
+              }
+            end
           end
 
         when "textDocument/didChange"
@@ -131,33 +235,106 @@ module Steep
             register_code_to_worker [path], worker: least_busy_worker()
           end
 
-          each_worker do |worker|
-            worker << message
-          end
-
-        when "textDocument/hover"
-          interaction_worker << message
+          broadcast_notification(message)
 
-        when "textDocument/completion"
-          interaction_worker << message
+        when "textDocument/hover", "textDocument/completion"
+          send_request(message, worker: interaction_worker) do |handler|
+            handler.on_completion do |response|
+              write_queue << response
+            end
+          end
 
         when "textDocument/open"
           # Ignores open notification
 
         when "workspace/symbol"
-          signature_worker << message
+          send_request(message, worker: signature_worker) do |handler|
+            handler.on_completion do |response|
+              write_queue << response
+            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] }
+
+                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 send_notification(message, worker:)
+        Steep.logger.info "Sending notification #{message[:method]} to #{worker.name}"
+        worker << 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
+      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
+
+        each_worker do |worker|
+          worker << message
+        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
+        end
       end
 
       def paths_for(worker)
@@ -177,15 +354,24 @@ module Steep
       def register_code_to_worker(paths, worker:)
         paths_for(worker).merge(paths)
 
-        worker << {
-          method: "workspace/executeCommand",
-          params: LSP::Interface::ExecuteCommandParams.new(
-            command: "steep/registerSourceToWorker",
-            arguments: paths.map do |path|
-              "file://#{project.absolute_path(path)}"
-            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
+        )
+      end
+
+      def kill
+        each_worker do |worker|
+          worker.kill
+        end
       end
     end
   end