steep 0.13.0 → 0.16.2

data/lib/steep/server/code_worker.rb

@@ -0,0 +1,151 @@
+module Steep
+  module Server
+    class CodeWorker < BaseWorker
+      LSP = LanguageServer::Protocol
+
+      include Utils
+
+      attr_reader :target_files
+      attr_reader :queue
+
+      def initialize(project:, reader:, writer:, queue: Queue.new)
+        super(project: project, reader: reader, writer: writer)
+
+        @target_files = {}
+        @queue = queue
+      end
+
+      def enqueue_type_check(target:, path:, version: target_files[path])
+        Steep.logger.info "Enqueueing type check: #{path}(#{version})@#{target.name}..."
+        target_files[path] = version
+        queue << [path, version, target]
+      end
+
+      def each_type_check_subject(path:, version:)
+        case
+        when !(updated_targets = project.targets.select {|target| target.signature_file?(path) }).empty?
+          updated_targets.each do |target|
+            target_files.each_key do |path|
+              if target.source_file?(path)
+                yield target, path, target_files[path]
+              end
+            end
+          end
+
+        when target = project.targets.find {|target| target.source_file?(path) }
+          if target_files.key?(path)
+            yield target, path, version
+          end
+        end
+      end
+
+      def typecheck_file(path, target)
+        Steep.logger.info "Starting type checking: #{path}@#{target.name}..."
+
+        source = target.source_files[path]
+        target.type_check(target_sources: [source], validate_signatures: false)
+
+        Steep.logger.info "Finished type checking: #{path}@#{target.name}"
+
+        diagnostics = source_diagnostics(source)
+
+        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: diagnostics
+          )
+        )
+      end
+
+      def source_diagnostics(source)
+        case status = source.status
+        when Project::SourceFile::ParseErrorStatus
+          []
+        when Project::SourceFile::AnnotationSyntaxErrorStatus
+          [
+            LSP::Interface::Diagnostic.new(
+              message: "Annotation syntax error: #{status.error.cause.message}",
+              severity: LSP::Constant::DiagnosticSeverity::ERROR,
+              range: LSP::Interface::Range.new(
+                start: LSP::Interface::Position.new(
+                  line: status.location.start_line - 1,
+                  character: status.location.start_column
+                ),
+                end: LSP::Interface::Position.new(
+                  line: status.location.end_line - 1,
+                  character: status.location.end_column
+                )
+              )
+            )
+          ]
+        when Project::SourceFile::TypeCheckStatus
+          status.typing.errors.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
+        when Project::SourceFile::TypeCheckErrorStatus
+          []
+        end
+      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|
+            target.source_files.each_key do |path|
+              if target_files.key?(path)
+                enqueue_type_check(target: target, path: path, version: target_files[path])
+              end
+            end
+          end
+
+        when "workspace/executeCommand"
+          if request[:params][:command] == "steep/registerSourceToWorker"
+            paths = request[:params][:arguments].map {|arg| source_path(URI.parse(arg)) }
+            paths.each do |path|
+              target_files[path] = 0
+            end
+          end
+
+        when "textDocument/didChange"
+          update_source(request) do |path, version|
+            if target_files.key?(path)
+              target_files[path] = version
+            end
+          end
+
+          path = source_path(URI.parse(request[:params][:textDocument][:uri]))
+          version = request[:params][:textDocument][:version]
+          each_type_check_subject(path: path, version: version) do |target, path, version|
+            enqueue_type_check(target: target, path: path, version: version)
+          end
+        end
+      end
+
+      def handle_job(job)
+        path, version, target = job
+        if !version || target_files[path] == version
+          typecheck_file(path, target)
+        else
+          Steep.logger.info "Skipping type check: #{path}@#{target.name}, queued version=#{version}, latest version=#{target_files[path]}"
+        end
+      end
+    end
+  end
+end

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