steep 0.14.0 → 0.16.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86924db409406024edb29a087196304bacba8730dfa3c986c604fbe8b6b9a6fd
-  data.tar.gz: d688f6b2f58343da51328f13bc26da7e4e54de7f1dd9393f0cd98d48c5ea8420
+  metadata.gz: 2b1c04c7f20a2ed355b58570363447b3e8f2bd1710407de1e23c7b9fbe279cb8
+  data.tar.gz: 62101db41144f3fd218ee8478ab377f3414ad1d8a7689ac73356aa28bf7f6842
 SHA512:
-  metadata.gz: a70b109afc79267f2a47425dcc8b93f05074fbffa1e410fa62824b5a94320f18a9274182ad2fbaa4083867dd0bab9e4e8796fc8b472edd2328d2b332e76f9f66
-  data.tar.gz: 6b4dc08b74b0f042b325180f1b358862d510fefe06a9e07f06380bbf7e86f47e3547d365d0cc94a278c80946befec64689a5c56e87a3e820db767103727e69f7
+  metadata.gz: d8ac130b1adb7755709f4b1590939b442d6d4b4aa5ea38a95423db539a1b52b0c4078abf1a543b92a84477d99846d5ab30060dc26c693f52785de0c205041a2d
+  data.tar.gz: e7ccec14707e49d51b88429ab0922c4e6fbbc190bbafb0e107c30ea681b04415245e40708909fd28458a89a565a816fd88a6bfa1c14b76e24185a2ece153148c

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.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))
+* More flow sensitive type checking
+
 ## 0.14.0 (2020-02-24)
 
 * Implementat LSP _completion_. ([#119](https://github.com/soutaro/steep/pull/119))

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,10 +8,12 @@ require "logger"
 require "active_support/tagged_logging"
 require "rainbow"
 require "listen"
-require 'pry'
 require 'language_server-protocol'
+require "etc"
+require "open3"
+require "stringio"
 
-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"
@@ -86,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

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
@@ -235,7 +235,7 @@ module Steep
 
           method_type.type_params.map do |name|
             if fvs.include?(name)
-              type = Ruby::Signature::Types::Variable.new(name: name, location: nil),
+              type = RBS::Types::Variable.new(name: name, location: nil),
               alpha_vars << name
               alpha_types << type
               type_params << type.name
@@ -245,13 +245,13 @@ module Steep
           end
           subst = Interface::Substitution.build(alpha_vars, alpha_types)
 
-          type = Ruby::Signature::MethodType.new(
+          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)
 
-              Ruby::Signature::MethodType::Block.new(
+              RBS::MethodType::Block.new(
                 type: function_1(block_type.params, block_type.return_type),
                 required: !block.optional
               )
@@ -543,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