steep 0.13.0 → 0.16.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e95857ced793435c07c948b2a51ac914c52816811ae8e5d18337bcf946eb33d
-  data.tar.gz: 9038e63999222be3e0b7172aa423056ef7792b905e1d277271fa795b6ca06889
+  metadata.gz: 551b6bb90b8fe98210d56cf53f62fb57e1bf0ce74e4c40ad931ddfe598507437
+  data.tar.gz: b01aed4e95d34dd6fad93fbeac1e5a427dbfa94e5ea9ce4130d2e89f14693159
 SHA512:
-  metadata.gz: 2747b3e5f3303ae48a91e76b2256cd1e402e7022caa714083267da0820f1bce2d81188586e551a10158d4c6716ab7a8db8562aa84b31c98731872b08d05048c9
-  data.tar.gz: 9d5bd44685d8228ee304bdaf94ae52e5eef2a2871580e7190ef941ea510406eab28bdb3aa6849fd9234649da10cd9344e2c38ba309a11a73cca70c6ed7e946e3
+  metadata.gz: 1e7aa1961819c9998182ef50ddd6d50c18985a9c2697715d35e062a069c87cd71bff416cb900a3bb3b5fff5c0a85970e3cb7f9e2183ca99656be6f87a4a4fdb5
+  data.tar.gz: 846810f3de6b4ec1a0e9f0a07ee3755c2e1258de6e7344339eef3e35b1912d6b591e36c55ef6e108f60c79a06ff9fed7ee940512ade80ba91bdab1a21e71bc28

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,34 @@
 
 ## master
 
+## 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))
+* More flow sensitive type checking
+
+## 0.14.0 (2020-02-24)
+
+* Implementat LSP _completion_. ([#119](https://github.com/soutaro/steep/pull/119))
+* Update ruby-signature. ([#120](https://github.com/soutaro/steep/pull/120))
+* Rescue errors during `langserver`. ([#121](https://github.com/soutaro/steep/pull/121))
+* Pass hint when type checking `return`. ([#122](https://github.com/soutaro/steep/pull/122))
+* Remove trailing spaces from Steepfile. ([#118](https://github.com/soutaro/steep/pull/118))
+
 ## 0.13.0 (2020-02-16)
 
 * Improve LSP _hover_ support. ([#117](https://github.com/soutaro/steep/pull/117))

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

@@ -10,8 +10,10 @@ require "rainbow"
 require "listen"
 require 'pry'
 require 'language_server-protocol'
+require "etc"
+require "open3"
 
-require "ruby/signature"
+require "rbs"
 
 require "steep/ast/namespace"
 require "steep/names"
@@ -61,12 +63,23 @@ require "steep/typing"
 require "steep/errors"
 require "steep/type_construction"
 require "steep/type_inference/context"
+require "steep/type_inference/context_array"
 require "steep/type_inference/send_args"
 require "steep/type_inference/block_params"
 require "steep/type_inference/constant_env"
 require "steep/type_inference/type_env"
+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"
@@ -74,6 +87,7 @@ require "steep/project/target"
 require "steep/project/dsl"
 require "steep/project/file_loader"
 require "steep/project/hover_content"
+require "steep/project/completion_provider"
 require "steep/drivers/utils/driver_helper"
 require "steep/drivers/check"
 require "steep/drivers/validate"
@@ -85,11 +99,14 @@ 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
 end
 
+$stderr = STDERR
+
 module Steep
   def self.logger
     @logger
@@ -114,4 +131,19 @@ module Steep
 
   @logger = nil
   self.log_output = STDERR
+
+  def self.measure(message)
+    start = Time.now
+    yield.tap do
+      time = Time.now - start
+      self.logger.info "#{message} took #{time} seconds"
+    end
+  end
+
+  def self.log_error(exn, message: "Unexpected error: #{exn.inspect}")
+    Steep.logger.error message
+    exn.backtrace.each do |loc|
+      Steep.logger.warn "  #{loc}"
+    end
+  end
 end

data/lib/steep/annotation_parser.rb

@@ -2,7 +2,7 @@ module Steep
   class AnnotationParser
     VAR_NAME = /[a-z][A-Za-z0-9_]*/
     METHOD_NAME = Regexp.union(
-      /[A-Za-z][A-Za-z0-9_]*[?!]?/
+      /[^.:\s]+/
     )
     CONST_NAME = Regexp.union(
       /(::)?([A-Z][A-Za-z0-9_]*::)*[A-Z][A-Za-z0-9_]*/
@@ -34,7 +34,7 @@ module Steep
     TYPE_PARAMS = /(\[(?<params>#{PARAM}(,\s*#{PARAM})*)\])?/
 
     def parse_type(string)
-      factory.type(Ruby::Signature::Parser.parse_type(string))
+      factory.type(RBS::Parser.parse_type(string))
     end
 
     # @type ${keyword} ${name}: ${type}
@@ -68,7 +68,7 @@ module Steep
           name = match[:name]
           type = match[:type]
 
-          method_type = factory.method_type(Ruby::Signature::Parser.parse_method_type(type), self_type: AST::Types::Self.new)
+          method_type = factory.method_type(RBS::Parser.parse_method_type(type), self_type: AST::Types::Self.new)
 
           AST::Annotation::MethodType.new(name: name.to_sym,
                                           type: method_type,
@@ -160,7 +160,7 @@ module Steep
         end
       end
 
-    rescue Ruby::Signature::Parser::SyntaxError, Ruby::Signature::Parser::SemanticsError => exn
+    rescue RBS::Parser::SyntaxError, RBS::Parser::SemanticsError => exn
       raise SyntaxError.new(source: src, location: location, exn: exn)
     end
   end

data/lib/steep/ast/buffer.rb

@@ -10,21 +10,25 @@ module Steep
         @name = name
         @content = content
 
-        @lines = content.lines
+        @lines = content.split(/\n/, -1)
 
         @ranges = []
         offset = 0
-        lines.each do |line|
-          size = line.bytesize
-          range = offset .. (offset+size)
-          ranges << range
-          offset += size
+        lines.each.with_index do |line, index|
+          if index == lines.size - 1
+            ranges << (offset..offset)
+          else
+            size = line.size
+            range = offset..(offset+size)
+            ranges << range
+            offset += size+1
+          end
         end
       end
 
       def pos_to_loc(pos)
         index = ranges.bsearch_index do |range|
-          pos < range.end
+          pos <= range.end
         end
 
         if index

data/lib/steep/ast/builtin.rb

@@ -88,6 +88,14 @@ module Steep
         AST::Types::Boolean.new
       end
 
+      def self.bottom_type
+        AST::Types::Bot.new
+      end
+
+      def self.top_type
+        AST::Types::Top.new
+      end
+
       def self.optional(type)
         AST::Types::Union.build(types: [type, nil_type])
       end

data/lib/steep/ast/types/factory.rb

@@ -10,56 +10,56 @@ module Steep
 
         def type(type)
           case type
-          when Ruby::Signature::Types::Bases::Any
+          when RBS::Types::Bases::Any
             Any.new(location: nil)
-          when Ruby::Signature::Types::Bases::Class
+          when RBS::Types::Bases::Class
             Class.new(location: nil)
-          when Ruby::Signature::Types::Bases::Instance
+          when RBS::Types::Bases::Instance
             Instance.new(location: nil)
-          when Ruby::Signature::Types::Bases::Self
+          when RBS::Types::Bases::Self
             Self.new(location: nil)
-          when Ruby::Signature::Types::Bases::Top
+          when RBS::Types::Bases::Top
             Top.new(location: nil)
-          when Ruby::Signature::Types::Bases::Bottom
+          when RBS::Types::Bases::Bottom
             Bot.new(location: nil)
-          when Ruby::Signature::Types::Bases::Bool
+          when RBS::Types::Bases::Bool
             Boolean.new(location: nil)
-          when Ruby::Signature::Types::Bases::Void
+          when RBS::Types::Bases::Void
             Void.new(location: nil)
-          when Ruby::Signature::Types::Bases::Nil
+          when RBS::Types::Bases::Nil
             Nil.new(location: nil)
-          when Ruby::Signature::Types::Variable
+          when RBS::Types::Variable
             Var.new(name: type.name, location: nil)
-          when Ruby::Signature::Types::ClassSingleton
+          when RBS::Types::ClassSingleton
             type_name = type_name(type.name)
             Name::Class.new(name: type_name, location: nil, constructor: nil)
-          when Ruby::Signature::Types::ClassInstance
+          when RBS::Types::ClassInstance
             type_name = type_name(type.name)
             args = type.args.map {|arg| type(arg) }
             Name::Instance.new(name: type_name, args: args, location: nil)
-          when Ruby::Signature::Types::Interface
+          when RBS::Types::Interface
             type_name = type_name(type.name)
             args = type.args.map {|arg| type(arg) }
             Name::Interface.new(name: type_name, args: args, location: nil)
-          when Ruby::Signature::Types::Alias
+          when RBS::Types::Alias
             type_name = type_name(type.name)
             Name::Alias.new(name: type_name, args: [], location: nil)
-          when Ruby::Signature::Types::Union
+          when RBS::Types::Union
             Union.build(types: type.types.map {|ty| type(ty) }, location: nil)
-          when Ruby::Signature::Types::Intersection
+          when RBS::Types::Intersection
             Intersection.build(types: type.types.map {|ty| type(ty) }, location: nil)
-          when Ruby::Signature::Types::Optional
+          when RBS::Types::Optional
             Union.build(types: [type(type.type), Nil.new(location: nil)], location: nil)
-          when Ruby::Signature::Types::Literal
+          when RBS::Types::Literal
             Literal.new(value: type.literal, location: nil)
-          when Ruby::Signature::Types::Tuple
+          when RBS::Types::Tuple
             Tuple.new(types: type.types.map {|ty| type(ty) }, location: nil)
-          when Ruby::Signature::Types::Record
+          when RBS::Types::Record
             elements = type.fields.each.with_object({}) do |(key, value), hash|
               hash[key] = type(value)
             end
             Record.new(elements: elements, location: nil)
-          when Ruby::Signature::Types::Proc
+          when RBS::Types::Proc
             params = params(type.type)
             return_type = type(type.type.return_type)
             Proc.new(params: params, return_type: return_type, location: nil)
@@ -71,56 +71,56 @@ module Steep
         def type_1(type)
           case type
           when Any
-            Ruby::Signature::Types::Bases::Any.new(location: nil)
+            RBS::Types::Bases::Any.new(location: nil)
           when Class
-            Ruby::Signature::Types::Bases::Class.new(location: nil)
+            RBS::Types::Bases::Class.new(location: nil)
           when Instance
-            Ruby::Signature::Types::Bases::Instance.new(location: nil)
+            RBS::Types::Bases::Instance.new(location: nil)
           when Self
-            Ruby::Signature::Types::Bases::Self.new(location: nil)
+            RBS::Types::Bases::Self.new(location: nil)
           when Top
-            Ruby::Signature::Types::Bases::Top.new(location: nil)
+            RBS::Types::Bases::Top.new(location: nil)
           when Bot
-            Ruby::Signature::Types::Bases::Bottom.new(location: nil)
+            RBS::Types::Bases::Bottom.new(location: nil)
           when Boolean
-            Ruby::Signature::Types::Bases::Bool.new(location: nil)
+            RBS::Types::Bases::Bool.new(location: nil)
           when Void
-            Ruby::Signature::Types::Bases::Void.new(location: nil)
+            RBS::Types::Bases::Void.new(location: nil)
           when Nil
-            Ruby::Signature::Types::Bases::Nil.new(location: nil)
+            RBS::Types::Bases::Nil.new(location: nil)
           when Var
-            Ruby::Signature::Types::Variable.new(name: type.name, location: nil)
+            RBS::Types::Variable.new(name: type.name, location: nil)
           when Name::Class, Name::Module
-            Ruby::Signature::Types::ClassSingleton.new(name: type_name_1(type.name), location: nil)
+            RBS::Types::ClassSingleton.new(name: type_name_1(type.name), location: nil)
           when Name::Instance
-            Ruby::Signature::Types::ClassInstance.new(
+            RBS::Types::ClassInstance.new(
               name: type_name_1(type.name),
               args: type.args.map {|arg| type_1(arg) },
               location: nil
             )
           when Name::Interface
-            Ruby::Signature::Types::Interface.new(
+            RBS::Types::Interface.new(
               name: type_name_1(type.name),
               args: type.args.map {|arg| type_1(arg) },
               location: nil
             )
           when Name::Alias
             type.args.empty? or raise "alias type with args is not supported"
-            Ruby::Signature::Types::Alias.new(name: type_name_1(type.name), location: nil)
+            RBS::Types::Alias.new(name: type_name_1(type.name), location: nil)
           when Union
-            Ruby::Signature::Types::Union.new(
+            RBS::Types::Union.new(
               types: type.types.map {|ty| type_1(ty) },
               location: nil
             )
           when Intersection
-            Ruby::Signature::Types::Intersection.new(
+            RBS::Types::Intersection.new(
               types: type.types.map {|ty| type_1(ty) },
               location: nil
             )
           when Literal
-            Ruby::Signature::Types::Literal.new(literal: type.value, location: nil)
+            RBS::Types::Literal.new(literal: type.value, location: nil)
           when Tuple
-            Ruby::Signature::Types::Tuple.new(
+            RBS::Types::Tuple.new(
               types: type.types.map {|ty| type_1(ty) },
               location: nil
             )
@@ -128,9 +128,9 @@ module Steep
             fields = type.elements.each.with_object({}) do |(key, value), hash|
               hash[key] = type_1(value)
             end
-            Ruby::Signature::Types::Record.new(fields: fields, location: nil)
+            RBS::Types::Record.new(fields: fields, location: nil)
           when Proc
-            Ruby::Signature::Types::Proc.new(
+            RBS::Types::Proc.new(
               type: function_1(type.params, type.return_type),
               location: nil
             )
@@ -151,7 +151,7 @@ module Steep
         end
 
         def type_name_1(name)
-          Ruby::Signature::TypeName.new(name: name.name, namespace: namespace_1(name.namespace))
+          RBS::TypeName.new(name: name.name, namespace: namespace_1(name.namespace))
         end
 
         def namespace(namespace)
@@ -159,18 +159,18 @@ module Steep
         end
 
         def namespace_1(namespace)
-          Ruby::Signature::Namespace.parse(namespace.to_s)
+          RBS::Namespace.parse(namespace.to_s)
         end
 
         def function_1(params, return_type)
-          Ruby::Signature::Types::Function.new(
-            required_positionals: params.required.map {|type| Ruby::Signature::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            optional_positionals: params.optional.map {|type| Ruby::Signature::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            rest_positionals: params.rest&.yield_self {|type| Ruby::Signature::Types::Function::Param.new(name: nil, type: type_1(type)) },
+          RBS::Types::Function.new(
+            required_positionals: params.required.map {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+            optional_positionals: params.optional.map {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+            rest_positionals: params.rest&.yield_self {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
             trailing_positionals: [],
-            required_keywords: params.required_keywords.transform_values {|type| Ruby::Signature::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            optional_keywords: params.optional_keywords.transform_values {|type| Ruby::Signature::Types::Function::Param.new(name: nil, type: type_1(type)) },
-            rest_keywords: params.rest_keywords&.yield_self {|type| Ruby::Signature::Types::Function::Param.new(name: nil, type: type_1(type)) },
+            required_keywords: params.required_keywords.transform_values {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+            optional_keywords: params.optional_keywords.transform_values {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
+            rest_keywords: params.rest_keywords&.yield_self {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
             return_type: type_1(return_type)
           )
         end
@@ -187,47 +187,82 @@ module Steep
         end
 
         def method_type(method_type, self_type:)
-          case method_type
-          when Ruby::Signature::MethodType
-            fvs = self_type.free_variables()
-
-            type_params = []
-            alpha_vars = []
-            alpha_types = []
-
-            method_type.type_params.map do |name|
-              if fvs.include?(name)
-                type = Types::Var.fresh(name)
-                alpha_vars << name
-                alpha_types << type
-                type_params << type.name
-              else
-                type_params << name
-              end
+          fvs = self_type.free_variables()
+
+          type_params = []
+          alpha_vars = []
+          alpha_types = []
+
+          method_type.type_params.map do |name|
+            if fvs.include?(name)
+              type = Types::Var.fresh(name)
+              alpha_vars << name
+              alpha_types << type
+              type_params << type.name
+            else
+              type_params << name
             end
-            subst = Interface::Substitution.build(alpha_vars, alpha_types)
-
-            type = Interface::MethodType.new(
-              type_params: type_params,
-              return_type: type(method_type.type.return_type).subst(subst),
-              params: params(method_type.type).subst(subst),
-              location: nil,
-              block: method_type.block&.yield_self do |block|
-                Interface::Block.new(
-                  optional: !block.required,
-                  type: Proc.new(params: params(block.type).subst(subst),
-                                 return_type: type(block.type.return_type).subst(subst), location: nil)
-                )
-              end
-            )
+          end
+          subst = Interface::Substitution.build(alpha_vars, alpha_types)
+
+          type = Interface::MethodType.new(
+            type_params: type_params,
+            return_type: type(method_type.type.return_type).subst(subst),
+            params: params(method_type.type).subst(subst),
+            location: nil,
+            block: method_type.block&.yield_self do |block|
+              Interface::Block.new(
+                optional: !block.required,
+                type: Proc.new(params: params(block.type).subst(subst),
+                               return_type: type(block.type.return_type).subst(subst), location: nil)
+              )
+            end
+          )
+
+          if block_given?
+            yield type
+          else
+            type
+          end
+        end
+
+        def method_type_1(method_type, self_type:)
+          fvs = self_type.free_variables()
 
-            if block_given?
-              yield type
+          type_params = []
+          alpha_vars = []
+          alpha_types = []
+
+          method_type.type_params.map do |name|
+            if fvs.include?(name)
+              type = RBS::Types::Variable.new(name: name, location: nil),
+              alpha_vars << name
+              alpha_types << type
+              type_params << type.name
             else
-              type
+              type_params << name
             end
-          when :any
-            :any
+          end
+          subst = Interface::Substitution.build(alpha_vars, alpha_types)
+
+          type = RBS::MethodType.new(
+            type_params: type_params,
+            type: function_1(method_type.params.subst(subst), method_type.return_type.subst(subst)),
+            block: method_type.block&.yield_self do |block|
+              block_type = block.type.subst(subst)
+
+              RBS::MethodType::Block.new(
+                type: function_1(block_type.params, block_type.return_type),
+                required: !block.optional
+              )
+            end,
+            location: nil
+          )
+
+          if block_given?
+            yield type
+          else
+            type
           end
         end
 
@@ -508,12 +543,12 @@ module Steep
 
         def module_name?(type_name)
           name = type_name_1(type_name)
-          env.class?(name) && env.find_class(name).is_a?(Ruby::Signature::AST::Declarations::Module)
+          env.class?(name) && env.find_class(name).is_a?(RBS::AST::Declarations::Module)
         end
 
         def class_name?(type_name)
           name = type_name_1(type_name)
-          env.class?(name) && env.find_class(name).is_a?(Ruby::Signature::AST::Declarations::Class)
+          env.class?(name) && env.find_class(name).is_a?(RBS::AST::Declarations::Class)
         end
 
         def env