steep 0.36.0 → 0.37.0

data/lib/steep/subtyping/check.rb

@@ -319,17 +319,20 @@ module Steep
             end
 
           when relation.sub_type.is_a?(AST::Types::Proc) && relation.super_type.is_a?(AST::Types::Proc)
-            check_method_params(:__proc__,
-                                relation.sub_type.params, relation.super_type.params,
-                                self_type: self_type,
-                                assumption: assumption,
-                                trace: trace,
-                                constraints: constraints).then do
-              check(Relation.new(sub_type: relation.sub_type.return_type, super_type: relation.super_type.return_type),
-                     self_type: self_type,
-                     assumption: assumption,
-                     trace: trace,
-                     constraints: constraints)
+            name = :__proc__
+
+            sub_type = relation.sub_type
+            super_type = relation.super_type
+
+            check_method_params(name, sub_type.type.params, super_type.type.params, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints).then do
+              check_block_given(name, sub_type.block, super_type.block, trace: trace, constraints: constraints).then do
+                check_block_params(name, sub_type.block, super_type.block, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints).then do
+                  check_block_return(sub_type.block, super_type.block, self_type: self_type, assumption: assumption, trace: trace, constraints:constraints).then do
+                    relation = Relation.new(super_type: super_type.type.return_type, sub_type: sub_type.type.return_type)
+                    check(relation, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)
+                  end
+                end
+              end
             end
 
           when relation.sub_type.is_a?(AST::Types::Tuple) && relation.super_type.is_a?(AST::Types::Tuple)
@@ -700,12 +703,12 @@ module Steep
 
       def check_method_type(name, sub_type, super_type, self_type:, assumption:, trace:, constraints:)
         Steep.logger.tagged("#{name}: #{sub_type} <: #{super_type}") do
-          check_method_params(name, sub_type.params, super_type.params, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints).then do
+          check_method_params(name, sub_type.type.params, super_type.type.params, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints).then do
             check_block_given(name, sub_type.block, super_type.block, trace: trace, constraints: constraints).then do
               check_block_params(name, sub_type.block, super_type.block, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints).then do
                 check_block_return(sub_type.block, super_type.block, self_type: self_type, assumption: assumption, trace: trace, constraints:constraints).then do
-                  relation = Relation.new(super_type: super_type.return_type,
-                                          sub_type: sub_type.return_type)
+                  relation = Relation.new(super_type: super_type.type.return_type,
+                                          sub_type: sub_type.type.return_type)
                   check(relation, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)
                 end
               end
@@ -750,10 +753,10 @@ module Steep
 
       def match_method_type(name, sub_type, super_type, trace:)
         [].tap do |pairs|
-          match_params(name, sub_type.params, super_type.params, trace: trace).yield_self do |result|
+          match_params(name, sub_type.type.params, super_type.type.params, trace: trace).yield_self do |result|
             return result unless result.is_a?(Array)
             pairs.push(*result)
-            pairs.push [sub_type.return_type, super_type.return_type]
+            pairs.push [sub_type.type.return_type, super_type.type.return_type]
 
             case
             when !super_type.block && !sub_type.block

data/lib/steep/subtyping/variable_occurrence.rb

@@ -10,12 +10,12 @@ module Steep
       end
 
       def add_method_type(method_type)
-        method_type.params.each_type do |type|
+        method_type.type.params.each_type do |type|
           each_var(type) do |var|
             params << var
           end
         end
-        each_var(method_type.return_type) do |var|
+        each_var(method_type.type.return_type) do |var|
           returns << var
         end
 

data/lib/steep/subtyping/variable_variance.rb

@@ -25,8 +25,8 @@ module Steep
         covariants = Set.new
         contravariants = Set.new
 
-        add_params(method_type.params, block: false, contravariants: contravariants, covariants: covariants)
-        add_type(method_type.return_type, variance: :covariant, covariants: covariants, contravariants: contravariants)
+        add_params(method_type.type.params, block: false, contravariants: contravariants, covariants: covariants)
+        add_type(method_type.type.return_type, variance: :covariant, covariants: covariants, contravariants: contravariants)
 
         method_type.block&.type&.yield_self do |proc|
           add_params(proc.params, block: true, contravariants: contravariants, covariants: covariants)

data/lib/steep/type_construction.rb

@@ -140,10 +140,10 @@ module Steep
 
       method_type = annotation_method_type || definition_method_type
 
-      if annots&.return_type && method_type&.return_type
-        check_relation(sub_type: annots.return_type, super_type: method_type.return_type).else do |result|
+      if annots&.return_type && method_type&.type&.return_type
+        check_relation(sub_type: annots.return_type, super_type: method_type.type.return_type).else do |result|
           typing.add_error Errors::MethodReturnTypeAnnotationMismatch.new(node: node,
-                                                                          method_type: method_type.return_type,
+                                                                          method_type: method_type.type.return_type,
                                                                           annotation_type: annots.return_type,
                                                                           result: result)
         end
@@ -152,19 +152,18 @@ module Steep
       # constructor_method = method&.attributes&.include?(:constructor)
 
       if method_type
-        var_types = TypeConstruction.parameter_types(args, method_type)
-        unless TypeConstruction.valid_parameter_env?(var_types, args.reject {|arg| arg.type == :blockarg}, method_type.params)
+        var_types = TypeConstruction.parameter_types(args, method_type.type)
+        unless TypeConstruction.valid_parameter_env?(var_types, args.reject {|arg| arg.type == :blockarg}, method_type.type.params)
           typing.add_error Errors::MethodArityMismatch.new(node: node)
         end
       end
 
       if (block_arg = args.find {|arg| arg.type == :blockarg})
         if method_type&.block
-          block_type = if method_type.block.optional?
-                         AST::Types::Union.build(types: [method_type.block.type, AST::Builtin.nil_type])
-                       else
-                         method_type.block.type
-                       end
+          block_type = AST::Types::Proc.new(type: method_type.block.type, block: nil)
+          if method_type.block.optional?
+            block_type = AST::Types::Union.build(types: [block_type, AST::Builtin.nil_type])
+          end
           var_types[block_arg.children[0]] = block_type
         end
       end
@@ -183,7 +182,7 @@ module Steep
         name: method_name,
         method: definition && definition.methods[method_name],
         method_type: method_type,
-        return_type: annots.return_type || method_type&.return_type || AST::Builtin.any_type,
+        return_type: annots.return_type || method_type&.type&.return_type || AST::Builtin.any_type,
         constructor: false,
         super_method: super_method
       )
@@ -1404,7 +1403,7 @@ module Steep
             if method_context&.method
               if method_context.super_method
                 types = method_context.super_method.method_types.map {|method_type|
-                  checker.factory.method_type(method_type, self_type: self_type, method_decls: Set[]).return_type
+                  checker.factory.method_type(method_type, self_type: self_type, method_decls: Set[]).type.return_type
                 }
                 add_typing(node, type: union_type(*types))
               else
@@ -2022,17 +2021,25 @@ module Steep
             if hint.is_a?(AST::Types::Proc) && value.type == :sym
               if hint.one_arg?
                 # Assumes Symbol#to_proc implementation
-                param_type = hint.params.required[0]
+                param_type = hint.type.params.required[0]
                 interface = checker.factory.interface(param_type, private: true)
                 method = interface.methods[value.children[0]]
                 if method
                   return_types = method.method_types.select {|method_type|
-                    method_type.params.each_type.count == 0
-                  }.map(&:return_type)
+                    method_type.type.params.empty?
+                  }.map {|method_type|
+                    method_type.type.return_type
+                  }
 
                   unless return_types.empty?
-                    type = AST::Types::Proc.new(params: Interface::Params.empty.update(required: [param_type]),
-                                                return_type: AST::Types::Union.build(types: return_types))
+                    type = AST::Types::Proc.new(
+                      type: Interface::Function.new(
+                        params: Interface::Function::Params.empty.update(required: [param_type]),
+                        return_type: AST::Types::Union.build(types: return_types),
+                        location: nil
+                      ),
+                      block: nil
+                    )
                   end
                 end
               else
@@ -2362,8 +2369,8 @@ module Steep
 
       case type_hint
       when AST::Types::Proc
-        params_hint = type_hint.params
-        return_hint = type_hint.return_type
+        params_hint = type_hint.type.params
+        return_hint = type_hint.type.return_type
       end
 
       block_constr = for_block(
@@ -2393,8 +2400,12 @@ module Steep
       end
 
       block_type = AST::Types::Proc.new(
-        params: params_hint || params.params_type,
-        return_type: return_type
+        type: Interface::Function.new(
+          params: params_hint || params.params_type,
+          return_type: return_type,
+          location: nil
+        ),
+        block: nil
       )
 
       add_typing node, type: block_type
@@ -2600,7 +2611,7 @@ module Steep
 
       results = method.method_types.flat_map do |method_type|
         Steep.logger.tagged method_type.to_s do
-          zips = args.zips(method_type.params, method_type.block&.type)
+          zips = args.zips(method_type.type.params, method_type.block&.type)
 
           zips.map do |arg_pairs|
             typing.new_child(node_range) do |child_typing|
@@ -2632,7 +2643,7 @@ module Steep
           context: context.method_context,
           method_name: method_name,
           receiver_type: receiver_type,
-          return_type: method_type.return_type,
+          return_type: method_type.type.return_type,
           errors: [error],
           method_decls: all_decls
         )
@@ -2655,7 +2666,7 @@ module Steep
     end
 
     def check_keyword_arg(receiver_type:, node:, method_type:, constraints:)
-      params = method_type.params
+      params = method_type.type.params
 
       case node.type
       when :hash
@@ -2757,7 +2768,7 @@ module Steep
           )
         else
           hash_elements = params.required_keywords.merge(
-            method_type.params.optional_keywords.transform_values do |type|
+            params.optional_keywords.transform_values do |type|
               AST::Types::Union.build(types: [type, AST::Builtin.nil_type])
             end
           )
@@ -2840,7 +2851,7 @@ module Steep
                 block_params: block_params_,
                 block_param_hint: method_type.block.type.params,
                 block_annotations: block_annotations,
-                node_type_hint: method_type.return_type
+                node_type_hint: method_type.type.return_type
               )
               block_constr = block_constr.with_new_typing(
                 block_constr.typing.new_child(
@@ -2870,7 +2881,7 @@ module Steep
                 checker,
                 self_type: self_type,
                 variance: variance,
-                variables: method_type.params.free_variables + method_type.block.type.params.free_variables
+                variables: method_type.type.params.free_variables + method_type.block.type.params.free_variables
               )
               method_type = method_type.subst(s)
               block_constr = block_constr.update_lvar_env {|env| env.subst(s) }
@@ -2896,22 +2907,36 @@ module Steep
                 s = constraints.solution(checker, self_type: self_type, variance: variance, variables: fresh_vars)
                 method_type = method_type.subst(s)
 
-                return_type = method_type.return_type
+                return_type = method_type.type.return_type
                 if break_type = block_annotations.break_type
                   return_type = union_type(break_type, return_type)
                 end
 
               when Subtyping::Result::Failure
-                block_type = AST::Types::Proc.new(
-                  params: method_type.block.type.params || block_params.params_type,
-                  return_type: block_body_type
+                given_block_type = AST::Types::Proc.new(
+                  type: Interface::Function.new(
+                    params: method_type.block.type.params || block_params.params_type,
+                    return_type: block_body_type,
+                    location: nil
+                  ),
+                  block: nil
+                )
+
+                method_block_type = AST::Types::Proc.new(
+                  type: Interface::Function.new(
+                    params: method_type.block.type.params,
+                    return_type: method_type.block.type.return_type,
+                    location: nil
+                  ),
+                  block: nil
                 )
+
                 errors << Errors::BlockTypeMismatch.new(node: node,
-                                                        expected: method_type.block.type,
-                                                        actual: block_type,
+                                                        expected: method_block_type,
+                                                        actual: given_block_type,
                                                         result: result)
 
-                return_type = method_type.return_type
+                return_type = method_type.type.return_type
               end
 
               block_constr.typing.save!
@@ -2985,23 +3010,24 @@ module Steep
           else
             begin
               method_type = method_type.subst(constraints.solution(checker, self_type: self_type, variance: variance, variables: occurence.params))
-              block_type, constr = constr.synthesize(args.block_pass_arg, hint: topdown_hint ? method_type.block.type : nil)
-              result = check_relation(
-                sub_type: block_type,
-                super_type: method_type.block.yield_self {|expected_block|
-                  if expected_block.optional?
-                    AST::Builtin.optional(expected_block.type)
-                  else
-                    expected_block.type
-                  end
-                },
-                constraints: constraints
-              )
+              hint_type = if topdown_hint
+                            AST::Types::Proc.new(type: method_type.block.type, block: nil)
+                          end
+              given_block_type, constr = constr.synthesize(args.block_pass_arg, hint: hint_type)
+              method_block_type = method_type.block.yield_self {|expected_block|
+                proc_type = AST::Types::Proc.new(type: expected_block.type, block: nil)
+                if expected_block.optional?
+                  AST::Builtin.optional(proc_type)
+                else
+                  proc_type
+                end
+              }
 
+              result = check_relation(sub_type: given_block_type, super_type: method_block_type, constraints: constraints)
               result.else do |result|
                 errors << Errors::BlockTypeMismatch.new(node: node,
-                                                        expected: method_type.block.type,
-                                                        actual: block_type,
+                                                        expected: method_block_type,
+                                                        actual: given_block_type,
                                                         result: result)
               end
 
@@ -3018,7 +3044,7 @@ module Steep
                  receiver_type: receiver_type,
                  method_name: method_name,
                  actual_method_type: method_type,
-                 return_type: return_type || method_type.return_type,
+                 return_type: return_type || method_type.type.return_type,
                  method_decls: method_type.method_decls
                )
              else
@@ -3027,7 +3053,7 @@ module Steep
                  context: context.method_context,
                  receiver_type: receiver_type,
                  method_name: method_name,
-                 return_type: return_type || method_type.return_type,
+                 return_type: return_type || method_type.type.return_type,
                  method_decls: method_type.method_decls,
                  errors: errors
                )

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

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.36.0"
+  VERSION = "0.37.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/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.17.0"
+  spec.add_runtime_dependency "rbs", ">= 0.20.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 0.36.0
+  version: 0.37.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-11-16 00:00:00.000000000 Z
+date: 2020-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -104,16 +104,16 @@ dependencies:
   name: rbs
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.17.0
+        version: 0.20.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.17.0
+        version: 0.20.0
 description: Gradual Typing for Ruby
 email:
 - matsumoto@soutaro.com
@@ -178,6 +178,8 @@ files:
 - lib/steep/drivers/watch.rb
 - lib/steep/drivers/worker.rb
 - lib/steep/errors.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 +357,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