steep 0.15.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 498c3c95c9c03e8ef047c774aff47158d8681e2ae485d5b0449a74fae33cd06b
-  data.tar.gz: 64e9572dc4ec5b5fea6035c1a1fbb7241a758f76c5d328d2ac0011c37e176044
+  metadata.gz: f60fa7be29b63a36a6f25cb94138d558d0bbaa652cb40ab5f2a4a24f1a0d58ac
+  data.tar.gz: 83582c3c37c5afefe079a545860e96a8edce020b891755b49f6a1cbdf53cce04
 SHA512:
-  metadata.gz: acef7a13109ecd0660d72dff4559b4432f96c62f79aa4dcb762722f9a96678bb6f68f0bd288017381c6ebef65f9648a24f2b349d2af28f1a6f0c66560d56aee6
-  data.tar.gz: 9d31c49a37770c7493cefcde0f608ee6b6c94bd5fa1935c3ce963bae70b3e526b678000ae1b2b9f59d94a775c5103cbabf7effd480262725db476f70e6124dcf
+  metadata.gz: 38e917a0030c6f0f993d6d0bd6bd9e26bb955cdd08609802df87992f7242933f03f3b35311c53fec9e6f74a12cb5d2237c5e03d6461fc56f44d019b8011ed12e
+  data.tar.gz: 5a5fa1b3502b23d3a9e6c1391de6c3313e8309adbbf353589eda27ed356414201ec2c6f6cdceb01b5f2afd8425a777a3d02921e509ba15674295c65f04bbdc0e

data/.gitmodules

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

data/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## master
 
+## 0.17.0 (2020-06-13)
+
+* Fix `steep watch` and `steep langserver` to correctly handle error message filterings based on options ([#152](https://github.com/soutaro/steep/pull/152))
+* Fix typing of collections ([#151](https://github.com/soutaro/steep/pull/151))
+
+## 0.16.3
+
+* Fix `steep watch` ([#147](https://github.com/soutaro/steep/pull/147))
+* Stop using pry ([#148](https://github.com/soutaro/steep/pull/148))
+
+## 0.16.2 (2020-05-27)
+
+* Update gems ([#144](https://github.com/soutaro/steep/pull/144), [#145](https://github.com/soutaro/steep/pull/145))
+
+## 0.16.1 (2020-05-22)
+
+* Fix constant resolution ([#143](https://github.com/soutaro/steep/pull/143))
+* Fix RBS diagnostics line number in LSP ([#142](https://github.com/soutaro/steep/pull/142))
+* Fix crash caused by hover on `def` in LSP ([#140](https://github.com/soutaro/steep/pull/140)) 
+
+## 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/Rakefile

@@ -8,19 +8,6 @@ Rake::TestTask.new(:test) do |t|
 end
 
 task :default => :test
-task :build => :parser
-task :test => :parser
-task :install => [:reset, :parser]
-
-task :parser do
-  Dir.chdir "vendor/ruby-signature" do
-    sh "bundle exec rake parser"
-  end
-end
-
-task :reset do
-  sh "git submodule update -f --init"
-end
 
 task :smoke do
   sh "bundle", "exec", "bin/smoke_runner.rb", *Dir.glob("smoke/*")

data/bin/setup

@@ -5,5 +5,3 @@ set -vx
 
 bundle install
 
-# Do any other automated setup that you need to do here
-bundle exec rake reset parser

data/bin/smoke_runner.rb

@@ -2,7 +2,6 @@
 
 require "pathname"
 
-$LOAD_PATH << Pathname(__dir__) + '../vendor/ruby-signature/lib'
 $LOAD_PATH << Pathname(__dir__) + "../lib"
 
 require "steep"

data/exe/steep

@@ -2,7 +2,6 @@
 
 require 'pathname'
 
-$LOAD_PATH << Pathname(__dir__) + "../vendor/ruby-signature/lib"
 $LOAD_PATH << Pathname(__dir__) + "../lib"
 
 require 'steep'

data/lib/steep.rb

@@ -8,8 +8,10 @@ require "logger"
 require "active_support/tagged_logging"
 require "rainbow"
 require "listen"
-require 'pry'
 require 'language_server-protocol'
+require "etc"
+require "open3"
+require "stringio"
 
 require "rbs"
 
@@ -70,6 +72,14 @@ require "steep/type_inference/local_variable_type_env"
 require "steep/type_inference/logic"
 require "steep/ast/types"
 
+require "steep/server/utils"
+require "steep/server/base_worker"
+require "steep/server/code_worker"
+require "steep/server/signature_worker"
+require "steep/server/worker_process"
+require "steep/server/interaction_worker"
+require "steep/server/master"
+
 require "steep/project"
 require "steep/project/file"
 require "steep/project/options"
@@ -89,6 +99,7 @@ require "steep/drivers/trace_printer"
 require "steep/drivers/print_project"
 require "steep/drivers/init"
 require "steep/drivers/vendor"
+require "steep/drivers/worker"
 
 if ENV["NO_COLOR"]
   Rainbow.enabled = false

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/check.rb

@@ -53,18 +53,7 @@ module Steep
               status.type_check_sources.each do |source_file|
                 case source_file.status
                 when Project::SourceFile::TypeCheckStatus
-                  source_file.errors.reject do |error|
-                    case
-                    when error.is_a?(Errors::FallbackAny)
-                      target.options.allow_fallback_any
-                    when error.is_a?(Errors::MethodDefinitionMissing)
-                      target.options.allow_missing_definitions
-                    when error.is_a?(Errors::NoMethod)
-                      target.options.allow_unknown_method_calls
-                    when error.is_a?(Errors::UnknownConstantAssigned)
-                      target.options.allow_unknown_constant_assignment
-                    end
-                  end.each do |error|
+                  source_file.errors.select {|error| target.options.error_to_report?(error) }.each do |error|
                     error.print_to stdout
                   end
                 when Project::SourceFile::TypeCheckErrorStatus

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