steep 0.15.0 → 0.16.0

data/lib/steep/server/interaction_worker.rb

@@ -0,0 +1,281 @@
+module Steep
+  module Server
+    class InteractionWorker < BaseWorker
+      attr_reader :queue
+
+      def initialize(project:, reader:, writer:, queue: Queue.new)
+        super(project: project, reader: reader, writer: writer)
+        @queue = queue
+      end
+
+      def handle_job(job)
+        Steep.logger.debug "Handling job: id=#{job[:id]}, result=#{job[:result]&.to_hash}"
+        writer.write(job)
+      end
+
+      def handle_request(request)
+        case request[:method]
+        when "initialize"
+          # nop
+
+        when "textDocument/didChange"
+          update_source(request)
+
+        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]
+          column = request[:params][:position][:character]
+
+          queue << {
+            id: id,
+            result: response_to_hover(path: path, line: line, column: column)
+          }
+
+        when "textDocument/completion"
+          id = request[:id]
+
+          params = request[:params]
+          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]
+
+          queue << {
+            id: id,
+            result: response_to_completion(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.logger.debug { "path=#{path}, line=#{line}, column=#{column}" }
+
+          hover = Project::HoverContent.new(project: project)
+          content = hover.content_for(path: path, line: line+1, column: column+1)
+          if content
+            range = content.location.yield_self do |location|
+              start_position = { line: location.line - 1, character: location.column }
+              end_position = { line: location.last_line - 1, character: location.last_column }
+              { start: start_position, end: end_position }
+            end
+
+            LSP::Interface::Hover.new(
+              contents: { kind: "markdown", value: format_hover(content) },
+              range: range
+            )
+          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
+          "`#{content.name}`: `#{content.type.to_s}`"
+        when Project::HoverContent::MethodCallContent
+          method_name = case content.method_name
+                        when Project::HoverContent::InstanceMethodName
+                          "#{content.method_name.class_name}##{content.method_name.method_name}"
+                        when Project::HoverContent::SingletonMethodName
+                          "#{content.method_name.class_name}.#{content.method_name.method_name}"
+                        else
+                          nil
+                        end
+
+          if method_name
+            string = <<HOVER
+```
+#{method_name} ~> #{content.type}
+```
+HOVER
+            if content.definition
+              if content.definition.comment
+                string << "\n----\n\n#{content.definition.comment.string}"
+              end
+
+              string << "\n----\n\n#{content.definition.method_types.map {|x| "- `#{x}`\n" }.join()}"
+            end
+          else
+            "`#{content.type}`"
+          end
+        when Project::HoverContent::DefinitionContent
+          string = <<HOVER
+```
+def #{content.method_name}: #{content.method_type}
+```
+HOVER
+          if (comment = content.definition.comment)
+            string << "\n----\n\n#{comment.string}\n"
+          end
+
+          if content.definition.method_types.size > 1
+            string << "\n----\n\n#{content.definition.method_types.map {|x| "- `#{x}`\n" }.join()}"
+          end
+
+          string
+        when Project::HoverContent::TypeContent
+          "`#{content.type}`"
+        end
+      end
+
+      def response_to_completion(path:, line:, column:, trigger:)
+        Steep.logger.tagged("#response_to_completion") do
+          Steep.logger.info "path: #{path}, line: #{line}, column: #{column}, trigger: #{trigger}"
+
+          target = project.targets.find {|target| target.source_file?(path) } or return
+          target.type_check(target_sources: [], validate_signatures: false)
+
+          case (status = target&.status)
+          when Project::Target::TypeCheckStatus
+            subtyping = status.subtyping
+            source = target.source_files[path]
+
+            provider = Project::CompletionProvider.new(source_text: source.content, path: path, subtyping: subtyping)
+            items = begin
+                      provider.run(line: line, column: column)
+                    rescue Parser::SyntaxError
+                      []
+                    end
+
+            completion_items = items.map do |item|
+              format_completion_item(item)
+            end
+
+            Steep.logger.debug "items = #{completion_items.inspect}"
+
+            LSP::Interface::CompletionList.new(
+              is_incomplete: false,
+              items: completion_items
+            )
+          end
+        end
+      end
+
+      def format_completion_item(item)
+        range = LanguageServer::Protocol::Interface::Range.new(
+          start: LanguageServer::Protocol::Interface::Position.new(
+            line: item.range.start.line-1,
+            character: item.range.start.column
+          ),
+          end: LanguageServer::Protocol::Interface::Position.new(
+            line: item.range.end.line-1,
+            character: item.range.end.column
+          )
+        )
+
+        case item
+        when Project::CompletionProvider::LocalVariableItem
+          LanguageServer::Protocol::Interface::CompletionItem.new(
+            label: item.identifier,
+            kind: LanguageServer::Protocol::Constant::CompletionItemKind::VARIABLE,
+            detail: "#{item.identifier}: #{item.type}",
+            text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
+              range: range,
+              new_text: "#{item.identifier}"
+            )
+          )
+        when Project::CompletionProvider::MethodNameItem
+          label = "def #{item.identifier}: #{item.method_type}"
+          method_type_snippet = method_type_to_snippet(item.method_type)
+          LanguageServer::Protocol::Interface::CompletionItem.new(
+            label: label,
+            kind: LanguageServer::Protocol::Constant::CompletionItemKind::METHOD,
+            text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
+              new_text: "#{item.identifier}#{method_type_snippet}",
+              range: range
+            ),
+            documentation: item.definition.comment&.string,
+            insert_text_format: LanguageServer::Protocol::Constant::InsertTextFormat::SNIPPET
+          )
+        when Project::CompletionProvider::InstanceVariableItem
+          label = "#{item.identifier}: #{item.type}"
+          LanguageServer::Protocol::Interface::CompletionItem.new(
+            label: label,
+            kind: LanguageServer::Protocol::Constant::CompletionItemKind::FIELD,
+            text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
+              range: range,
+              new_text: item.identifier,
+              ),
+            insert_text_format: LanguageServer::Protocol::Constant::InsertTextFormat::SNIPPET
+          )
+        end
+      end
+
+      def method_type_to_snippet(method_type)
+        params = if method_type.type.each_param.count == 0
+                   ""
+                 else
+                   "(#{params_to_snippet(method_type.type)})"
+                 end
+
+
+        block = if method_type.block
+                  open, space, close = if method_type.block.type.return_type.is_a?(RBS::Types::Bases::Void)
+                                         ["do", " ", "end"]
+                                       else
+                                         ["{", "", "}"]
+                                       end
+
+                  if method_type.block.type.each_param.count == 0
+                    " #{open} $0 #{close}"
+                  else
+                    " #{open}#{space}|#{params_to_snippet(method_type.block.type)}| $0 #{close}"
+                  end
+                else
+                  ""
+                end
+
+        "#{params}#{block}"
+      end
+
+      def params_to_snippet(fun)
+        params = []
+
+        index = 1
+
+        fun.required_positionals.each do |param|
+          if name = param.name
+            params << "${#{index}:#{param.type}}"
+          else
+            params << "${#{index}:#{param.type}}"
+          end
+
+          index += 1
+        end
+
+        if fun.rest_positionals
+          params << "${#{index}:*#{fun.rest_positionals.type}}"
+          index += 1
+        end
+
+        fun.trailing_positionals.each do |param|
+          if name = param.name
+            params << "${#{index}:#{param.type}}"
+          else
+            params << "${#{index}:#{param.type}}"
+          end
+
+          index += 1
+        end
+
+        fun.required_keywords.each do |keyword, param|
+          if name = param.name
+            params << "#{keyword}: ${#{index}:#{name}_}"
+          else
+            params << "#{keyword}: ${#{index}:#{param.type}_}"
+          end
+
+          index += 1
+        end
+
+        params.join(", ")
+      end
+    end
+  end
+end

data/lib/steep/server/master.rb

@@ -0,0 +1,196 @@
+module Steep
+  module Server
+    class Master
+      LSP = LanguageServer::Protocol
+
+      attr_reader :steepfile
+      attr_reader :project
+      attr_reader :reader, :writer
+      attr_reader :queue
+      attr_reader :worker_count
+      attr_reader :worker_to_paths
+
+      attr_reader :interaction_worker
+      attr_reader :signature_worker
+      attr_reader :code_workers
+
+      def initialize(project:, reader:, writer:, interaction_worker:, signature_worker:, code_workers:, queue: Queue.new)
+        @project = project
+        @reader = reader
+        @writer = writer
+        @queue = queue
+        @interaction_worker = interaction_worker
+        @signature_worker = signature_worker
+        @code_workers = code_workers
+        @worker_to_paths = {}
+      end
+
+      def start
+        source_paths = project.targets.flat_map {|target| target.source_files.keys }
+        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
+
+        Thread.new do
+          interaction_worker.reader.read do |message|
+            process_message_from_worker(message)
+          end
+        end
+
+        Thread.new do
+          signature_worker.reader.read do |message|
+            process_message_from_worker(message)
+          end
+        end
+
+        code_workers.each do |worker|
+          Thread.new do
+            worker.reader.read do |message|
+              process_message_from_worker(message)
+            end
+          end
+        end
+
+        Thread.new do
+          reader.read do |request|
+            process_message_from_client(request)
+          end
+        end
+
+        while job = queue.pop
+          writer.write(job)
+        end
+
+        writer.io.close
+
+        each_worker do |w|
+          w.shutdown()
+        end
+      end
+
+      def each_worker(&block)
+        if block_given?
+          yield interaction_worker
+          yield signature_worker
+          code_workers.each &block
+        else
+          enum_for :each_worker
+        end
+      end
+
+      def process_message_from_client(message)
+        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::FULL
+                ),
+                hover_provider: true,
+                completion_provider: LSP::Interface::CompletionOptions.new(
+                  trigger_characters: [".", "@"]
+                )
+              )
+            )
+          }
+
+          each_worker do |worker|
+            worker << message
+          end
+
+        when "textDocument/didChange"
+          uri = URI.parse(message[:params][:textDocument][:uri])
+          path = project.relative_path(Pathname(uri.path))
+          text = message[:params][:contentChanges][0][:text]
+
+          project.targets.each do |target|
+            case
+            when target.source_file?(path)
+              if text.empty? && !path.file?
+                Steep.logger.info { "Deleting source file: #{path}..." }
+                target.remove_source(path)
+              else
+                Steep.logger.info { "Updating source file: #{path}..." }
+                target.update_source(path, text)
+              end
+            when target.possible_source_file?(path)
+              Steep.logger.info { "Adding source file: #{path}..." }
+              target.add_source(path, text)
+            when target.signature_file?(path)
+              if text.empty? && !path.file?
+                Steep.logger.info { "Deleting signature file: #{path}..." }
+                target.remove_signature(path)
+              else
+                Steep.logger.info { "Updating signature file: #{path}..." }
+                target.update_signature(path, text)
+              end
+            when target.possible_signature_file?(path)
+              Steep.logger.info { "Adding signature file: #{path}..." }
+              target.add_signature(path, text)
+            end
+          end
+
+          unless registered_path?(path)
+            register_code_to_worker [path], worker: least_busy_worker()
+          end
+
+          each_worker do |worker|
+            worker << message
+          end
+
+        when "textDocument/hover"
+          interaction_worker << message
+
+        when "textDocument/completion"
+          interaction_worker << message
+
+        when "textDocument/open"
+          # Ignores open notification
+
+        when "shutdown"
+          queue << { id: id, result: nil }
+
+        when "exit"
+          queue << nil
+        end
+      end
+
+      def process_message_from_worker(message)
+        queue << message
+      end
+
+      def paths_for(worker)
+        worker_to_paths[worker] ||= Set[]
+      end
+
+      def least_busy_worker
+        code_workers.min_by do |w|
+          paths_for(w).size
+        end
+      end
+
+      def registered_path?(path)
+        worker_to_paths.each_value.any? {|set| set.include?(path) }
+      end
+
+      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
+          )
+        }
+      end
+    end
+  end
+end

data/lib/steep/server/signature_worker.rb

@@ -0,0 +1,148 @@
+module Steep
+  module Server
+    class SignatureWorker < BaseWorker
+      attr_reader :queue
+      attr_reader :last_target_validated_at
+
+      def initialize(project:, reader:, writer:, queue: Queue.new)
+        super(project: project, reader: reader, writer: writer)
+
+        @queue = queue
+        @last_target_validated_at = {}
+      end
+
+      def validate_signature_if_required(request)
+        path = source_path(URI.parse(request[:params][:textDocument][:uri]))
+
+        project.targets.each do |target|
+          if target.signature_file?(path)
+            enqueue_target target: target, timestamp: Time.now
+          end
+        end
+      end
+
+      def enqueue_target(target:, timestamp:)
+        Steep.logger.debug "queueing target #{target.name}@#{timestamp}"
+        last_target_validated_at[target] = timestamp
+        queue << [target, timestamp]
+      end
+
+      def handle_request(request)
+        case request[:method]
+        when "initialize"
+          # Don't respond to initialize request, but start type checking.
+          project.targets.each do |target|
+            enqueue_target(target: target, timestamp: Time.now)
+          end
+        when "textDocument/didChange"
+          update_source(request)
+          validate_signature_if_required(request)
+        end
+      end
+
+      def validate_signature(target, timestamp:)
+        Steep.logger.info "Starting signature validation: #{target.name} (#{timestamp})..."
+
+        target.type_check(target_sources: [], validate_signatures: true)
+
+        Steep.logger.info "Finished signature validation: #{target.name} (#{timestamp})"
+
+        diagnostics = case status = target.status
+                      when Project::Target::SignatureSyntaxErrorStatus
+                        target.signature_files.each.with_object({}) do |(path, file), hash|
+                          if file.status.is_a?(Project::SignatureFile::ParseErrorStatus)
+                            location = case error = file.status.error
+                                       when RBS::Parser::SyntaxError
+                                         if error.error_value.is_a?(String)
+                                           buf = RBS::Buffer.new(name: path, content: file.content)
+                                           RBS::Location.new(buffer: buf, start_pos: buf.content.size, end_pos: buf.content.size)
+                                         else
+                                           error.error_value.location
+                                         end
+                                       when RBS::Parser::SemanticsError
+                                         error.location
+                                       else
+                                         raise
+                                       end
+
+                            hash[path] =
+                              [
+                                LSP::Interface::Diagnostic.new(
+                                  message: file.status.error.message,
+                                  severity: LSP::Constant::DiagnosticSeverity::ERROR,
+                                  range: LSP::Interface::Range.new(
+                                    start: LSP::Interface::Position.new(
+                                      line: location.start_line,
+                                      character: location.start_column,
+                                    ),
+                                    end: LSP::Interface::Position.new(
+                                      line: location.end_line,
+                                      character: location.end_column
+                                    )
+                                  )
+                                )
+                              ]
+                          else
+                            hash[path] = []
+                          end
+                        end
+                      when Project::Target::SignatureValidationErrorStatus
+                        error_hash = status.errors.group_by {|error| error.location.buffer.name }
+
+                        target.signature_files.each_key.with_object({}) do |path, hash|
+                          errors = error_hash[path] || []
+                          hash[path] = errors.map do |error|
+                            LSP::Interface::Diagnostic.new(
+                              message: StringIO.new.tap {|io| error.puts(io) }.string.split(/\t/, 2).last,
+                              severity: LSP::Constant::DiagnosticSeverity::ERROR,
+                              range: LSP::Interface::Range.new(
+                                start: LSP::Interface::Position.new(
+                                  line: error.location.start_line,
+                                  character: error.location.start_column,
+                                  ),
+                                end: LSP::Interface::Position.new(
+                                  line: error.location.end_line,
+                                  character: error.location.end_column
+                                )
+                              )
+                            )
+                          end
+                        end
+                      when Project::Target::TypeCheckStatus
+                        target.signature_files.each_key.with_object({}) do |path, hash|
+                          hash[path] = []
+                        end
+                      else
+                        Steep.logger.info "Unexpected target status: #{status.class}"
+                      end
+
+        diagnostics.each do |path, diags|
+          writer.write(
+            method: :"textDocument/publishDiagnostics",
+            params: LSP::Interface::PublishDiagnosticsParams.new(
+              uri: URI.parse(project.absolute_path(path).to_s).tap {|uri| uri.scheme = "file"},
+              diagnostics: diags
+            )
+          )
+        end
+      end
+
+      def active_job?(target, timestamp)
+        if last_target_validated_at[target] == timestamp
+          sleep 0.1
+          last_target_validated_at[target] == timestamp
+        end
+      end
+
+      def handle_job(job)
+        target, timestamp = job
+
+        if active_job?(target, timestamp)
+          validate_signature(target, timestamp: timestamp)
+        else
+          Steep.logger.info "Skipping signature validation: #{target.name}, queued timestamp=#{timestamp}, latest timestamp=#{last_target_validated_at[target]}"
+        end
+      end
+    end
+  end
+end

data/lib/steep/server/utils.rb

@@ -0,0 +1,36 @@
+module Steep
+  module Server
+    module Utils
+      LSP = LanguageServer::Protocol
+
+      def source_path(uri)
+        project.relative_path(Pathname(uri.path))
+      end
+
+      def update_source(request)
+        path = source_path(URI.parse(request[:params][:textDocument][:uri]))
+        text = request[:params][:contentChanges][0][:text]
+        version = request[:params][:textDocument][:version]
+
+        Steep.logger.debug "Updateing source: path=#{path}, version=#{version}, size=#{text.bytesize}"
+
+        project.targets.each do |target|
+          case
+          when target.source_file?(path)
+            target.update_source path, text
+          when target.possible_source_file?(path)
+            target.add_source path, text
+          when target.signature_file?(path)
+            target.update_signature path, text
+          when target.possible_signature_file?(path)
+            target.add_signature path, text
+          end
+        end
+
+        if block_given?
+          yield path, version
+        end
+      end
+    end
+  end
+end