steep 0.15.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 498c3c95c9c03e8ef047c774aff47158d8681e2ae485d5b0449a74fae33cd06b
-  data.tar.gz: 64e9572dc4ec5b5fea6035c1a1fbb7241a758f76c5d328d2ac0011c37e176044
+  metadata.gz: b4dda8122216dc9af384ceba2c84f7cb1076df5be7060d2aa32dbaff32140ed6
+  data.tar.gz: d4ce7351acc02b06cd608a10639c00bc8bb1bed8ca81596bb1ed718112392a68
 SHA512:
-  metadata.gz: acef7a13109ecd0660d72dff4559b4432f96c62f79aa4dcb762722f9a96678bb6f68f0bd288017381c6ebef65f9648a24f2b349d2af28f1a6f0c66560d56aee6
-  data.tar.gz: 9d31c49a37770c7493cefcde0f608ee6b6c94bd5fa1935c3ce963bae70b3e526b678000ae1b2b9f59d94a775c5103cbabf7effd480262725db476f70e6124dcf
+  metadata.gz: 0bc09bf14d4fbfe8cea15d8f939efd2f9b75672a25fdfbbd19011461001786d15e7d84fadfa37cf67a0303f742c6b2a718855095603119276d1154c4b97cc673
+  data.tar.gz: 7d3d1d4f8acb18de067228fe38d52a7cb62dbd5049555fa748d96226c6ce1906fc49e034f3e19ae346c215ee89a715e04e0138b985cbedcc89b922499adc0a08

data/.gitmodules

@@ -1,3 +1,3 @@
 [submodule "vendor/ruby-signature"]
 	path = vendor/ruby-signature
-	url = https://github.com/ruby/ruby-signature.git
+	url = https://github.com/ruby/rbs.git

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## master
 
+## 0.16.0 (2020-05-19)
+
+* Spawn workers for type check performance ([#137](https://github.com/soutaro/steep/pull/137))
+* Fix `check` and `signature` methods in Steepfile ([8f3e4c7](https://github.com/soutaro/steep/pull/137/commits/8f3e4c75b29ac26920f02294be06d6c68dbd4dca))
+
 ## 0.15.0 (2020-05-05)
 
 * Add type checking configuration to dsl ([#132](https://github.com/soutaro/steep/pull/132))

data/lib/steep/cli.rb

@@ -34,7 +34,7 @@ module Steep
 
     def setup_command
       @command = argv.shift&.to_sym
-      if CLI.available_commands.include?(@command)
+      if CLI.available_commands.include?(@command) || @command == :worker
         true
       else
         stderr.puts "Unknown command: #{command}"
@@ -159,5 +159,20 @@ module Steep
       stdout.puts Steep::VERSION
       0
     end
+
+    def process_worker
+      Drivers::Worker.new(stdout: stdout, stderr: stderr, stdin: stdin).tap do |command|
+        OptionParser.new do |opts|
+          opts.banner = "Usage: steep worker [options] [dir]"
+          handle_logging_options opts
+
+          opts.on("--interaction") { command.worker_type = :interaction }
+          opts.on("--code") { command.worker_type = :code }
+          opts.on("--signature") { command.worker_type = :signature }
+          opts.on("--steepfile=PATH") {|path| command.steepfile = Pathname(path) }
+          opts.on("--name=NAME") {|name| command.worker_name = name }
+        end.parse!(argv)
+      end.run
+    end
   end
 end

data/lib/steep/drivers/annotations.rb

@@ -25,7 +25,7 @@ module Steep
 
         project.targets.each do |target|
           Steep.logger.tagged "target=#{target.name}" do
-            target.load_signatures do |_, subtyping, _|
+            target.load_signatures(validate: false) do |_, subtyping, _|
               case (status = target.status)
               when nil     # status set on error cases
                 target.source_files.each_value do |file|

data/lib/steep/drivers/langserver.rb

@@ -33,11 +33,6 @@ module Steep
         @project or raise "Empty #project"
       end
 
-      def enqueue_type_check(version)
-        @latest_update_version = version
-        type_check_queue << TypeCheckRequest.new(version: version)
-      end
-
       def run
         @project = load_config()
 
@@ -45,466 +40,22 @@ module Steep
         loader.load_sources([])
         loader.load_signatures()
 
-        start_type_check()
-
-        reader.read do |request|
-          Steep.logger.tagged "lsp" do
-            Steep.logger.debug { "Received a request: request=#{request.to_json}" }
-            handle_request(request) do |id, result|
-              if id
-                write_mutex.synchronize do
-                  Steep.logger.debug { "Writing response to #{id}: #{result.to_json}" }
-                  writer.write(id: id, result: result)
-                end
-              end
-            end
-          end
-        end
-
-        0
-      end
-
-      def write(method:, params:)
-        write_mutex.synchronize do
-          Steep.logger.debug { "Sending request: method=#{method}, params=#{params.to_json}"}
-          writer.write(method: method, params: params)
-        end
-      end
-
-      def handle_request(request)
-        id = request[:id]
-        method = request[:method].to_sym
-
-        Steep.logger.tagged "id=#{id}, method=#{method}" do
-          case method
-          when :initialize
-            yield id, LanguageServer::Protocol::Interface::InitializeResult.new(
-              capabilities: LanguageServer::Protocol::Interface::ServerCapabilities.new(
-                text_document_sync: LanguageServer::Protocol::Interface::TextDocumentSyncOptions.new(
-                  change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::FULL
-                ),
-                hover_provider: true,
-                completion_provider: LanguageServer::Protocol::Interface::CompletionOptions.new(
-                  trigger_characters: [".", "@"],
-                )
-              )
-            )
-
-            enqueue_type_check nil
-
-          when :"textDocument/completion"
-            Steep.logger.error request.inspect
-            begin
-              params = request[:params]
-              uri = URI.parse(params[:textDocument][:uri])
-              path = project.relative_path(Pathname(uri.path))
-              target = project.targets.find {|target| target.source_file?(path) }
-              case (status = target&.status)
-              when Project::Target::TypeCheckStatus
-                subtyping = status.subtyping
-                source = target.source_files[path]
-
-                line, column = params[:position].yield_self {|hash| [hash[:line]+1, hash[:character]] }
-                trigger = params[:context][:triggerCharacter]
-
-                Steep.logger.error "line: #{line}, column: #{column}, trigger: #{trigger}"
-
-                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}"
-
-                yield id, LanguageServer::Protocol::Interface::CompletionList.new(
-                  is_incomplete: false,
-                  items: completion_items
-                )
-              end
-
-            rescue Typing::UnknownNodeError => exn
-              Steep.log_error exn, message: "Failed to compute completion: #{exn.inspect}"
-              yield id, nil
-            end
-
-          when :"textDocument/didChange"
-            uri = URI.parse(request[:params][:textDocument][:uri])
-            path = project.relative_path(Pathname(uri.path))
-            text = request[:params][:contentChanges][0][:text]
-
-            Steep.logger.debug { "path=#{path}, content=#{text.lines.first&.chomp}..." }
-
-            project.targets.each do |target|
-              Steep.logger.tagged "target=#{target.name}" do
-                case
-                when target.source_file?(path)
-                  if text.empty? && !path.file?
-                    Steep.logger.info { "Deleting source file: #{path}..." }
-                    target.remove_source(path)
-                    report_diagnostics 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)
-                    report_diagnostics 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
-            end
-
-            version = request[:params][:textDocument][:version]
-            enqueue_type_check version
-          when :"textDocument/hover"
-            uri = URI.parse(request[:params][:textDocument][:uri])
-            path = project.relative_path(Pathname(uri.path))
-            line = request[:params][:position][:line]
-            column = request[:params][:position][:character]
-
-            yield id, response_to_hover(path: path, line: line, column: column)
-
-          when :shutdown
-            yield id, nil
-
-          when :exit
-            type_check_queue << nil
-            type_check_thread.join
-            exit
-          end
-        end
-      end
-
-      def start_type_check
-        @type_check_thread = Thread.start do
-          while request = type_check_queue.deq
-            if @latest_update_version == nil || @latest_update_version == request.version
-              begin
-                run_type_check()
-              rescue => exn
-                Steep.log_error exn
-              end
-            end
-          end
-        end
-      end
-
-      def run_type_check()
-        Steep.logger.tagged "#run_type_check" do
-          Steep.logger.info { "Running type check..." }
-          type_check project
-
-          Steep.logger.info { "Sending diagnostics..." }
-          project.targets.each do |target|
-            Steep.logger.tagged "target=#{target.name}, status=#{target.status.class}" do
-              Steep.logger.info { "Clearing signature diagnostics..." }
-              target.signature_files.each_value do |file|
-                report_diagnostics file.path, []
-              end
-
-              case (status = target.status)
-              when Project::Target::SignatureValidationErrorStatus
-                Steep.logger.info { "Signature validation error" }
-                status.errors.group_by(&:path).each do |path, errors|
-                  diagnostics = errors.map {|error| diagnostic_for_validation_error(error) }
-                  report_diagnostics path, diagnostics
-                end
-              when Project::Target::TypeCheckStatus
-                Steep.logger.info { "Type check" }
-                status.type_check_sources.each do |source|
-                  diagnostics = case source.status
-                                when Project::SourceFile::TypeCheckStatus
-                                  source.errors.map {|error| diagnostic_for_type_error(error) }
-                                when Project::SourceFile::AnnotationSyntaxErrorStatus
-                                  [diagnostics_raw(source.status.error.message, source.status.location)]
-                                when Project::SourceFile::ParseErrorStatus
-                                  []
-                                when Project::SourceFile::TypeCheckErrorStatus
-                                  Steep.log_error source.status.error
-                                  []
-                                end
-
-                  if diagnostics
-                    report_diagnostics source.path, diagnostics
-                  end
-                end
-              when Project::Target::SignatureSyntaxErrorStatus
-                Steep.logger.info { "Signature syntax error" }
-              end
-            end
-          end
-        end
-      end
-
-      def report_diagnostics(path, diagnostics)
-        Steep.logger.info { "Reporting #{diagnostics.size} diagnostics for #{path}..." }
-        write(
-          method: :"textDocument/publishDiagnostics",
-          params: LanguageServer::Protocol::Interface::PublishDiagnosticsParams.new(
-            uri: URI.parse(project.absolute_path(path).to_s).tap {|uri| uri.scheme = "file"},
-            diagnostics: diagnostics,
-          )
-        )
-      end
-
-      def diagnostic_for_validation_error(error)
-        LanguageServer::Protocol::Interface::Diagnostic.new(
-          message: StringIO.new("").tap {|io| error.puts(io) }.string,
-          severity: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
-          range: LanguageServer::Protocol::Interface::Range.new(
-            start: LanguageServer::Protocol::Interface::Position.new(
-              line: error.location.start_line - 1,
-              character: error.location.start_column,
-              ),
-            end: LanguageServer::Protocol::Interface::Position.new(
-              line: error.location.end_line - 1,
-              character: error.location.end_column,
-              ),
-            )
-        )
-      end
-
-      def diagnostics_raw(message, loc)
-        LanguageServer::Protocol::Interface::Diagnostic.new(
-          message: message,
-          severity: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
-          range: LanguageServer::Protocol::Interface::Range.new(
-            start: LanguageServer::Protocol::Interface::Position.new(
-              line: loc.start_line - 1,
-              character: loc.start_column,
-              ),
-            end: LanguageServer::Protocol::Interface::Position.new(
-              line: loc.end_line - 1,
-              character: loc.end_column,
-              ),
-            )
-        )
-      end
-
-      def diagnostic_for_type_error(error)
-        LanguageServer::Protocol::Interface::Diagnostic.new(
-          message: error.to_s,
-          severity: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
-          range: LanguageServer::Protocol::Interface::Range.new(
-            start: LanguageServer::Protocol::Interface::Position.new(
-              line: error.node.loc.line - 1,
-              character: error.node.loc.column,
-              ),
-            end: LanguageServer::Protocol::Interface::Position.new(
-              line: error.node.loc.last_line - 1,
-              character: error.node.loc.last_column,
-              ),
-            )
+        interaction_worker = Server::WorkerProcess.spawn_worker(:interaction, name: "interaction", steepfile: project.steepfile_path)
+        signature_worker = Server::WorkerProcess.spawn_worker(:signature, name: "signature", steepfile: project.steepfile_path)
+        code_workers = Server::WorkerProcess.spawn_code_workers(steepfile: project.steepfile_path)
+
+        master = Server::Master.new(
+          project: project,
+          reader: reader,
+          writer: writer,
+          interaction_worker: interaction_worker,
+          signature_worker: signature_worker,
+          code_workers: code_workers
         )
-      end
-
-      def response_to_hover(path:, line:, column:)
-        Steep.logger.info { "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
 
-          LanguageServer::Protocol::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
-
-      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 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
-          )
-        )
+        master.start()
 
-        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(", ")
+        0
       end
     end
   end

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

@@ -8,7 +8,7 @@ module Steep
           raise "Cannot find a configuration at #{path}: `steep init` to scaffold" unless path.file?
 
           steep_file_path = path.absolute? ? path : Pathname.pwd + path
-          Project.new(base_dir: steep_file_path.parent).tap do |project|
+          Project.new(steepfile_path: steep_file_path).tap do |project|
             Project::DSL.parse(project, path.read, filename: path.to_s)
           end
         end