steep 0.34.0 → 0.39.0

data/lib/steep/type_inference/block_params.rb

@@ -134,7 +134,7 @@ module Steep
           rest = rest_param&.yield_self {|param| param.type.args[0] }
         end
 
-        Interface::Params.new(
+        Interface::Function::Params.new(
           required: leadings,
           optional: optionals,
           rest: rest,

data/lib/steep/type_inference/constant_env.rb

@@ -15,9 +15,13 @@ module Steep
         @table = RBS::ConstantTable.new(builder: factory.definition_builder)
       end
 
+      def lookup_constant(name)
+        table.resolve_constant_reference(name, context: context)
+      end
+
       def lookup(name)
         cache[name] ||= begin
-          constant = table.resolve_constant_reference(name, context: context)
+          constant = lookup_constant(name)
 
           if constant
             factory.type(constant.type)

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -41,11 +41,17 @@ module Steep
 
         if type.is_a?(AST::Types::Logic::Base)
           vars.each do |var_name|
-            truthy_env = truthy_env.assign!(var_name, node: node, type: AST::Builtin.true_type)
-            falsy_env = truthy_env.assign!(var_name, node: node, type: AST::Builtin.false_type)
+            var_type = truthy_env[var_name]
+            truthy_type, falsy_type = factory.unwrap_optional(var_type)
+            falsy_type ||= AST::Builtin.nil_type
+            truthy_env = truthy_env.assign!(var_name, node: node, type: truthy_type) {|_, type, _| type }
+            falsy_env = truthy_env.assign!(var_name, node: node, type: falsy_type) {|_, type, _| type }
           end
 
           case type
+          when AST::Types::Logic::Env
+            truthy_env = type.truthy
+            falsy_env = type.falsy
           when AST::Types::Logic::ReceiverIsNil
             case value_node.type
             when :send
@@ -74,11 +80,16 @@ module Steep
 
                 if arg_type.is_a?(AST::Types::Name::Singleton)
                   receiver_vars.each do |var_name|
-                    var_type = env[var_name]
-                    truthy_type, falsy_type = type_case_select(var_type, arg_type.name)
-
-                    truthy_env = truthy_env.assign!(var_name, node: node, type: truthy_type)
-                    falsy_env = falsy_env.assign!(var_name, node: node, type: falsy_type)
+                    case var_name
+                    when :_, :__any__, :__skip__
+                      # skip
+                    else
+                      var_type = env[var_name]
+                      truthy_type, falsy_type = type_case_select(var_type, arg_type.name)
+
+                      truthy_env = truthy_env.assign!(var_name, node: node, type: truthy_type)
+                      falsy_env = falsy_env.assign!(var_name, node: node, type: falsy_type)
+                    end
                   end
                 end
               end
@@ -90,7 +101,7 @@ module Steep
 
               if receiver
                 _, arg_vars = decompose_value(arg)
-                receiver_type = typing.type_of(node: receiver)
+                receiver_type = factory.deep_expand_alias(typing.type_of(node: receiver))
 
                 if receiver_type.is_a?(AST::Types::Name::Singleton)
                   arg_vars.each do |var_name|
@@ -103,6 +114,23 @@ module Steep
                 end
               end
             end
+          when AST::Types::Logic::ArgEqualsReceiver
+            case value_node.type
+            when :send
+              receiver, _, arg = value_node.children
+
+              if receiver
+                _, arg_vars = decompose_value(arg)
+
+                arg_vars.each do |var_name|
+                  var_type = factory.deep_expand_alias(env[var_name])
+                  truthy_types, falsy_types = literal_var_type_case_select(receiver, var_type)
+
+                  truthy_env = truthy_env.assign!(var_name, node: node, type: AST::Types::Union.build(types: truthy_types, location: nil))
+                  falsy_env = falsy_env.assign!(var_name, node: node, type: AST::Types::Union.build(types: falsy_types, location: nil))
+                end
+              end
+            end
           when AST::Types::Logic::Not
             receiver, * = value_node.children
             receiver_type = typing.type_of(node: receiver)
@@ -153,6 +181,60 @@ module Steep
         end
       end
 
+      def literal_var_type_case_select(value_node, arg_type)
+        case arg_type
+        when AST::Types::Union
+          truthy_types = []
+          falsy_types = []
+
+          arg_type.types.each do |type|
+            ts, fs = literal_var_type_case_select(value_node, type)
+            truthy_types.push(*ts)
+            falsy_types.push(*fs)
+          end
+
+          [truthy_types, falsy_types]
+        else
+          value_type = typing.type_of(node: value_node)
+          types = [arg_type]
+
+          case value_node.type
+          when :nil
+            types.partition do |type|
+              type.is_a?(AST::Types::Nil) || AST::Builtin::NilClass.instance_type?(type)
+            end
+          when :true
+            types.partition do |type|
+              AST::Builtin::TrueClass.instance_type?(type) ||
+                (type.is_a?(AST::Types::Literal) && type.value == true)
+            end
+          when :false
+            types.partition do |type|
+              AST::Builtin::FalseClass.instance_type?(type) ||
+                (type.is_a?(AST::Types::Literal) && type.value == false)
+            end
+          when :int, :str, :sym
+            types.each.with_object([[], []]) do |type, pair|
+              true_types, false_types = pair
+
+              case
+              when type.is_a?(AST::Types::Literal)
+                if type.value == value_node.children[0]
+                  true_types << type
+                else
+                  false_types << type
+                end
+              else
+                true_types << AST::Types::Literal.new(value: value_node.children[0])
+                false_types << type
+              end
+            end
+          else
+            [[arg_type], [arg_type]]
+          end
+        end
+      end
+
       def type_case_select(type, klass)
         truth_types, false_types = type_case_select0(type, klass)
 
@@ -183,20 +265,6 @@ module Steep
 
           [truthy_types, falsy_types]
 
-        when AST::Types::Name::Instance
-          relation = Subtyping::Relation.new(sub_type: type, super_type: instance_type)
-          if subtyping.check(relation, constraints: Subtyping::Constraints.empty, self_type: AST::Types::Self.new).success?
-            [
-              [type],
-              []
-            ]
-          else
-            [
-              [],
-              [type]
-            ]
-          end
-
         when AST::Types::Name::Alias
           ty = factory.expand_alias(type)
           type_case_select0(ty, klass)
@@ -214,10 +282,18 @@ module Steep
           ]
 
         else
-          [
-            [],
-            [type]
-          ]
+          relation = Subtyping::Relation.new(sub_type: type, super_type: instance_type)
+          if subtyping.check(relation, constraints: Subtyping::Constraints.empty, self_type: AST::Types::Self.new).success?
+            [
+              [type],
+              []
+            ]
+          else
+            [
+              [],
+              [type]
+            ]
+          end
         end
       end
     end

data/lib/steep/typing.rb

@@ -21,8 +21,9 @@ module Steep
     attr_reader :contexts
     attr_reader :root_context
     attr_reader :method_calls
+    attr_reader :source_index
 
-    def initialize(source:, root_context:, parent: nil, parent_last_update: parent&.last_update, contexts: nil)
+    def initialize(source:, root_context:, parent: nil, parent_last_update: parent&.last_update, contexts: nil, source_index: nil)
       @source = source
 
       @parent = parent
@@ -35,6 +36,8 @@ module Steep
       @root_context = root_context
       @contexts = contexts || TypeInference::ContextArray.from_source(source: source)
       @method_calls = {}.compare_by_identity
+
+      @source_index = source_index || Index::SourceIndex.new(source: source)
     end
 
     def add_error(error)
@@ -195,7 +198,8 @@ module Steep
       child = self.class.new(source: source,
                              parent: self,
                              root_context: root_context,
-                             contexts: TypeInference::ContextArray.new(buffer: contexts.buffer, range: range, context: nil))
+                             contexts: TypeInference::ContextArray.new(buffer: contexts.buffer, range: range, context: nil),
+                             source_index: source_index.new_child)
       @should_update = true
 
       if block_given?
@@ -224,6 +228,8 @@ module Steep
       errors.each do |error|
         parent.add_error error
       end
+
+      parent.source_index.merge!(source_index)
     end
   end
 end

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.34.0"
+  VERSION = "0.39.0"
 end

data/smoke/tsort/Steepfile

@@ -0,0 +1,6 @@
+target :test do
+  signature "."
+  check "."
+
+  library "tsort"
+end

data/smoke/tsort/a.rb

@@ -0,0 +1,15 @@
+# ALLOW FAILURE
+
+require "tsort"
+
+# @type var g: Hash[Integer, Array[Integer]]
+g = {1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]}
+
+# @type var each_node: ^() { (Integer) -> void } -> void
+each_node = -> (&b) { g.each_key(&b) }
+# @type var each_child: ^(Integer) { (Integer) -> void } -> void
+each_child = -> (n, &b) { g[n].each(&b) }
+
+# @type var xs: Array[String]
+# !expects IncompatibleAssignment: lhs_type=::Array[::String], rhs_type=::Array[::Integer]
+xs = TSort.tsort(each_node, each_child)

data/smoke/type_case/a.rb

@@ -16,7 +16,7 @@ end
 
 case x
 when 1
-  # !expects NoMethodError: type=(::Integer | ::String | ::Symbol), method=foobar
+  # !expects NoMethodError: type=1, method=foobar
   x.foobar
 end
 

data/steep.gemspec

@@ -34,5 +34,5 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "rainbow", ">= 2.2.2", "< 4.0"
   spec.add_runtime_dependency "listen", "~> 3.0"
   spec.add_runtime_dependency "language_server-protocol", "~> 3.15.0.1"
-  spec.add_runtime_dependency "rbs", "~> 0.14.0"
+  spec.add_runtime_dependency "rbs", "~> 1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 0.34.0
+  version: 0.39.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-10-27 00:00:00.000000000 Z
+date: 2020-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -106,14 +106,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: 1.0.0
 description: Gradual Typing for Ruby
 email:
 - matsumoto@soutaro.com
@@ -178,6 +178,11 @@ files:
 - lib/steep/drivers/watch.rb
 - lib/steep/drivers/worker.rb
 - lib/steep/errors.rb
+- lib/steep/index/rbs_index.rb
+- lib/steep/index/signature_symbol_provider.rb
+- lib/steep/index/source_index.rb
+- lib/steep/interface/block.rb
+- lib/steep/interface/function.rb
 - lib/steep/interface/interface.rb
 - lib/steep/interface/method.rb
 - lib/steep/interface/method_type.rb
@@ -355,6 +360,8 @@ files:
 - smoke/toplevel/Steepfile
 - smoke/toplevel/a.rb
 - smoke/toplevel/a.rbs
+- smoke/tsort/Steepfile
+- smoke/tsort/a.rb
 - smoke/type_case/Steepfile
 - smoke/type_case/a.rb
 - smoke/yield/Steepfile
@@ -382,7 +389,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Gradual Typing for Ruby