steep 0.48.0 → 0.49.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72c3b61eccfe6a3f2cf2da22293bd7b50a001c25e82197b3efea52753857ff78
-  data.tar.gz: '08786e3140b0bbf10f79c5395a7026062abef6a690a9fefdf6ca464fbf13e92d'
+  metadata.gz: '0273968ec727f3b7c5c1007f9e27966c50ad7bc3128217a4ef30be4f97321037'
+  data.tar.gz: 195eb670673894e36af5e00ef911654f2a543c71e8de1d46c15e23035bef19c8
 SHA512:
-  metadata.gz: d3abc0d6f64deffebf187428be69cec72dc5c887e0ecb2fbc407c20e2dde66bae8ce3bdf5f7f8a43ccaa90c562fa9c178bb9cc93a3d3d5b7fa99d5e7344fbfdd
-  data.tar.gz: df16f83cf33224f0442124546d3406313dff27bd472fc60978864c40cdffcbb9aa8013bb049c940021ccb6e76c7a1338d9d30fc0fb07f71e306e7dae21885ad7
+  metadata.gz: '0908edc4a3221256f450c9fd945d7127bd9ece3fa0359b7da88be8cebea30f7c766e023b84527e89e8f0c7956752310a3b0e98343b8c4808bfde518a89284456'
+  data.tar.gz: 4004adb0d0e8f2e0cd2629cd7e0c2bd6513a3a48bbd96d1d77621bbe0979b73686ab9c8ad718e3243081fdf492ff9728b5bf6df8e7357e1b1cf810393dad264c

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## master
 
+## 0.49.0 (2022-03-08)
+
+* Better typing for `#flat_map` ([\#504](https://github.com/soutaro/steep/pull/504))
+* Support lambdas (`->`) with block ([\#503](https://github.com/soutaro/steep/pull/503))
+* Let proc type be `::Proc` class instance ([\#502](https://github.com/soutaro/steep/pull/502))
+* Disable contextual typing on `bool` type ([\#501](https://github.com/soutaro/steep/pull/501))
+* Type check `return` without value ([\#500](https://github.com/soutaro/steep/pull/500))
+
 ## 0.48.0 (2022-03-07)
 
 Steep supports all of the new features of RBS 2. 🎉

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    steep (0.48.0)
+    steep (0.49.0)
       activesupport (>= 5.1)
       language_server-protocol (>= 3.15, < 4.0)
       listen (~> 3.0)

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

@@ -28,6 +28,8 @@ module Steep
 
         include Helper::NoFreeVariables
 
+        include Helper::NoChild
+
         def level
           [1]
         end

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

@@ -28,6 +28,8 @@ module Steep
 
         include Helper::NoFreeVariables
 
+        include Helper::NoChild
+
         def level
           [0]
         end

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

@@ -28,6 +28,8 @@ module Steep
 
         include Helper::NoFreeVariables
 
+        include Helper::NoChild
+
         def level
           [2]
         end

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

@@ -30,6 +30,8 @@ module Steep
           @fvs = Set.new([self])
         end
 
+        include Helper::NoChild
+
         def level
           [0]
         end

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

@@ -393,7 +393,7 @@ module Steep
           when AST::Types::Name::Alias
             unwrap_optional(expand_alias(type))
           when AST::Types::Boolean
-            [AST::Builtin.true_type, AST::Builtin.false_type]
+            [type, type]
           else
             [type, nil]
           end

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

@@ -21,6 +21,14 @@ module Steep
             @fvs ||= Set.new
           end
         end
+
+        module NoChild
+          def each_child(&block)
+            unless block
+              enum_for :each_child
+            end
+          end
+        end
       end
     end
   end

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

@@ -26,6 +26,8 @@ module Steep
           @fvs = Set.new([self])
         end
 
+        include Helper::NoChild
+
         def to_s
           "instance"
         end

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

@@ -72,6 +72,10 @@ module Steep
 
         include Helper::ChildrenLevel
 
+        def each_child(&block)
+          types.each(&block)
+        end
+
         def level
           [0] + level_of_children(types)
         end

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

@@ -31,6 +31,8 @@ module Steep
 
         include Helper::NoFreeVariables
 
+        include Helper::NoChild
+
         def level
           [0]
         end

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

@@ -13,6 +13,8 @@ module Steep
             @fvs ||= Set[]
           end
 
+          include Helper::NoChild
+
           def hash
             self.class.hash
           end

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

@@ -72,6 +72,10 @@ module Steep
             end
           end
 
+          def each_child(&block)
+            args.each(&block)
+          end
+
           include Helper::ChildrenLevel
 
           def level
@@ -98,6 +102,8 @@ module Steep
           def with_location(new_location)
             self.class.new(name: name, location: new_location)
           end
+
+          include Helper::NoChild
         end
 
         class Instance < Applying

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

@@ -28,6 +28,8 @@ module Steep
 
         include Helper::NoFreeVariables
 
+        include Helper::NoChild
+
         def level
           [0]
         end

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

@@ -90,6 +90,15 @@ module Steep
         def block_required?
           block && !block.optional?
         end
+
+        def each_child(&block)
+          if block_given?
+            type.each_child(&block)
+            self.block&.type&.each_child(&block)
+          else
+            enum_for :each_child
+          end
+        end
       end
     end
   end

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

@@ -42,6 +42,10 @@ module Steep
 
         include Helper::ChildrenLevel
 
+        def each_child(&block)
+          elements.each_value(&block)
+        end
+
         def level
           [0] + level_of_children(elements.values)
         end

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

@@ -22,6 +22,8 @@ module Steep
           "self"
         end
 
+        include Helper::NoChild
+
         def subst(s)
           s.self_type or raise "Unexpected substitution: #{inspect}"
         end

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

@@ -28,6 +28,8 @@ module Steep
 
         include Helper::NoFreeVariables
 
+        include Helper::NoChild
+
         def level
           [2]
         end

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

@@ -40,6 +40,10 @@ module Steep
 
         include Helper::ChildrenLevel
 
+        def each_child(&block)
+          types.each(&block)
+        end
+
         def level
           [0] + level_of_children(types)
         end

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

@@ -70,6 +70,10 @@ module Steep
           end
         end
 
+        def each_child(&block)
+          types.each(&block)
+        end
+
         include Helper::ChildrenLevel
 
         def level

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

@@ -52,6 +52,8 @@ module Steep
           @fvs ||= Set.new([name])
         end
 
+        include Helper::NoChild
+
         def level
           [0]
         end

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

@@ -28,6 +28,8 @@ module Steep
 
         include Helper::NoFreeVariables
 
+        include Helper::NoChild
+
         def level
           [0]
         end

data/lib/steep/interface/function.rb

@@ -952,6 +952,10 @@ module Steep
         )
       end
 
+      def each_child(&block)
+        each_type(&block)
+      end
+
       def each_type(&block)
         if block_given?
           params.each_type(&block)

data/lib/steep/subtyping/check.rb

@@ -347,7 +347,7 @@ module Steep
 
         when relation.super_type.is_a?(AST::Types::Union)
           Any(relation) do |result|
-            relation.super_type.types.each do |super_type|
+            relation.super_type.types.sort_by {|ty| (path = hole_path(ty)) ? -path.size : 1 }.each do |super_type|
               rel = Relation.new(sub_type: relation.sub_type, super_type: super_type)
               result.add(rel) do
                 check_type(rel)
@@ -357,7 +357,7 @@ module Steep
 
         when relation.sub_type.is_a?(AST::Types::Intersection)
           Any(relation) do |result|
-            relation.sub_type.types.each do |sub_type|
+            relation.sub_type.types.sort_by {|ty| (path = hole_path(ty)) ? -path.size : 1 }.each do |sub_type|
               rel = Relation.new(sub_type: sub_type, super_type: relation.super_type)
               result.add(rel) do
                 check_type(rel)
@@ -483,6 +483,9 @@ module Steep
             check_interface(relation.map {|type| factory.interface(type, private: false) })
           end
 
+        when relation.sub_type.is_a?(AST::Types::Proc) && AST::Builtin::Proc.instance_type?(relation.super_type)
+          Success(relation)
+
         when relation.super_type.is_a?(AST::Types::Literal)
           case
           when relation.super_type.value == true && AST::Builtin::TrueClass.instance_type?(relation.sub_type)
@@ -971,6 +974,24 @@ module Steep
       def expand_alias(type, &block)
         factory.expand_alias(type, &block)
       end
+
+      # Returns the shortest type paths for one of the _unknown_ type variables.
+      # Returns nil if there is no path.
+      def hole_path(type, path = [])
+        case type
+        when AST::Types::Var
+          if constraints.unknown?(type.name)
+            [type]
+          else
+            nil
+          end
+        else
+          paths = type.each_child.map do |ty|
+            hole_path(ty, path)&.unshift(ty)
+          end
+          paths.compact.min_by(&:size)
+        end
+      end
     end
   end
 end

data/lib/steep/type_construction.rb

@@ -1005,7 +1005,7 @@ module Steep
           yield_self do
             send_node, params, body = node.children
             if send_node.type == :lambda
-              type_lambda(node, block_params: params, block_body: body, type_hint: hint)
+              type_lambda(node, params_node: params, body_node: body, type_hint: hint)
             else
               type_send(node, send_node: send_node, block_params: params, block_body: body, unwrap: send_node.type == :csend)
             end
@@ -1024,7 +1024,7 @@ module Steep
             params = Parser::AST::Node.new(:args, arg_nodes)
 
             if send_node.type == :lambda
-              type_lambda(node, block_params: params, block_body: body, type_hint: hint)
+              type_lambda(node, params_node: params, body_node: body, type_hint: hint)
             else
               type_send(node, send_node: send_node, block_params: params, block_body: body, unwrap: send_node.type == :csend)
             end
@@ -1181,9 +1181,9 @@ module Steep
 
         when :return
           yield_self do
-            if node.children.size > 0
-              method_return_type = expand_alias(method_context&.return_type)
+            method_return_type = expand_alias(method_context&.return_type)
 
+            if node.children.size > 0
               return_types = node.children.map do |value|
                 synthesize(
                   value,
@@ -1201,20 +1201,23 @@ module Steep
                              AST::Builtin::Array.instance_type(union_type(*return_types))
                            end
 
-              if method_return_type
-                unless method_return_type.is_a?(AST::Types::Void)
-                  result = check_relation(sub_type: value_type, super_type: method_return_type)
+            else
+              value_type = AST::Builtin.nil_type
+            end
 
-                  if result.failure?
-                    typing.add_error(
-                      Diagnostic::Ruby::ReturnTypeMismatch.new(
-                        node: node,
-                        expected: method_context&.return_type,
-                        actual: value_type,
-                        result: result
-                      )
+            if method_return_type
+              unless method_return_type.is_a?(AST::Types::Void)
+                result = check_relation(sub_type: value_type, super_type: method_return_type)
+
+                if result.failure?
+                  typing.add_error(
+                    Diagnostic::Ruby::ReturnTypeMismatch.new(
+                      node: node,
+                      expected: method_context&.return_type,
+                      actual: value_type,
+                      result: result
                     )
-                  end
+                  )
                 end
               end
             end
@@ -2724,20 +2727,22 @@ module Steep
       end
     end
 
-    def type_lambda(node, block_params:, block_body:, type_hint:)
+    def type_lambda(node, params_node:, body_node:, type_hint:)
       block_annotations = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
-      params = TypeInference::BlockParams.from_node(block_params, annotations: block_annotations)
+      params = TypeInference::BlockParams.from_node(params_node, annotations: block_annotations)
 
       case type_hint
       when AST::Types::Proc
         params_hint = type_hint.type.params
         return_hint = type_hint.type.return_type
+        block_hint = type_hint.block
       end
 
       block_constr = for_block(
         block_params: params,
         block_param_hint: params_hint,
         block_type_hint: return_hint,
+        block_block_hint: block_hint,
         block_annotations: block_annotations,
         node_type_hint: nil
       )
@@ -2748,10 +2753,30 @@ module Steep
         _, block_constr = block_constr.synthesize(param.node, hint: param.type)
       end
 
-      if block_body
+      block =
+        if block_param = params.block_param
+          if block_param_type = block_param.type
+            case block_param_type
+            when AST::Types::Proc
+              Interface::Block.new(type: block_param_type.type, optional: false)
+            when AST::Types::Union
+              if block_param_type.types.size == 2
+                if block_param_type.types.find {|t| t.is_a?(AST::Types::Nil) }
+                  if proc_type = block_param_type.types.find {|t| t.is_a?(AST::Types::Proc) }
+                    Interface::Block.new(type: proc_type.type, optional: true)
+                  end
+                end
+              end
+            end
+          else
+            type_hint.block
+          end
+        end
+
+      if body_node
         return_type = block_constr.synthesize_block(
           node: node,
-          block_body: block_body,
+          block_body: body_node,
           block_type_hint: return_hint
         )
 
@@ -2779,7 +2804,7 @@ module Steep
           return_type: return_type,
           location: nil
         ),
-        block: nil
+        block: block
       )
 
       add_typing node, type: block_type
@@ -3246,7 +3271,7 @@ module Steep
 
           if method_type.block
             # Method accepts block
-            pairs = method_type.block && block_params_&.zip(method_type.block.type.params)
+            pairs = method_type.block && block_params_&.zip(method_type.block.type.params, nil)
 
             if pairs
               # Block parameters are compatible with the block type
@@ -3254,6 +3279,7 @@ module Steep
                 block_params: block_params_,
                 block_param_hint: method_type.block.type.params,
                 block_type_hint: method_type.block.type.return_type,
+                block_block_hint: nil,
                 block_annotations: block_annotations,
                 node_type_hint: method_type.type.return_type
               )
@@ -3503,13 +3529,14 @@ module Steep
             message: "Unsupported block params pattern, probably masgn?"
           )
         )
-        block_params = TypeInference::BlockParams.new(leading_params: [], optional_params: [], rest_param: nil, trailing_params: [])
+        block_params = TypeInference::BlockParams.new(leading_params: [], optional_params: [], rest_param: nil, trailing_params: [], block_param: nil)
       end
 
       block_constr = for_block(
         block_params: block_params,
         block_param_hint: nil,
         block_type_hint: AST::Builtin.any_type,
+        block_block_hint: nil,
         block_annotations: block_annotations,
         node_type_hint: AST::Builtin.any_type
       )
@@ -3536,8 +3563,8 @@ module Steep
       end
     end
 
-    def for_block(block_params:, block_param_hint:, block_type_hint:, block_annotations:, node_type_hint:)
-      block_param_pairs = block_param_hint && block_params.zip(block_param_hint)
+    def for_block(block_params:, block_param_hint:, block_type_hint:, block_block_hint:, block_annotations:, node_type_hint:)
+      block_param_pairs = block_param_hint && block_params.zip(block_param_hint, block_block_hint)
 
       param_types_hash = {}
       if block_param_pairs

data/lib/steep/type_inference/block_params.rb

@@ -29,12 +29,14 @@ module Steep
       attr_reader :optional_params
       attr_reader :rest_param
       attr_reader :trailing_params
+      attr_reader :block_param
 
-      def initialize(leading_params:, optional_params:, rest_param:, trailing_params:)
+      def initialize(leading_params:, optional_params:, rest_param:, trailing_params:, block_param:)
         @leading_params = leading_params
         @optional_params = optional_params
         @rest_param = rest_param
         @trailing_params = trailing_params
+        @block_param = block_param
       end
 
       def params
@@ -43,6 +45,7 @@ module Steep
           params.push(*optional_params)
           params.push rest_param if rest_param
           params.push(*trailing_params)
+          params.push(block_param) if block_param
         end
       end
 
@@ -51,6 +54,7 @@ module Steep
         optional_params = []
         rest_param = nil
         trailing_params = []
+        block_param = nil
 
         default_params = leading_params
 
@@ -72,6 +76,9 @@ module Steep
           when :restarg
             default_params = trailing_params
             rest_param = Param.new(var: var, type: type, value: nil, node: arg)
+          when :blockarg
+            block_param = Param.new(var: var, type: type, value: nil, node: arg)
+            break
           end
         end
 
@@ -79,7 +86,8 @@ module Steep
           leading_params: leading_params,
           optional_params: optional_params,
           rest_param: rest_param,
-          trailing_params: trailing_params
+          trailing_params: trailing_params,
+          block_param: block_param
         )
       end
 
@@ -141,7 +149,7 @@ module Steep
         )
       end
 
-      def zip(params_type)
+      def zip(params_type, block)
         if trailing_params.any?
           Steep.logger.error "Block definition with trailing required parameters are not supported yet"
         end
@@ -204,6 +212,26 @@ module Steep
               end
             end
           end
+
+          if block_param
+            if block
+              proc_type =
+                if block.optional?
+                  AST::Types::Union.build(
+                    types: [
+                      AST::Types::Proc.new(type: block.type, block: nil),
+                      AST::Builtin.nil_type
+                    ]
+                  )
+                else
+                  AST::Types::Proc.new(type: block.type, block: nil)
+                end
+
+              zip << [block_param, proc_type]
+            else
+              zip << [block_param, AST::Builtin.nil_type]
+            end
+          end
         end
       end
 

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.48.0"
+  VERSION = "0.49.0"
 end

data/smoke/tsort/a.rb

@@ -8,5 +8,5 @@ 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]
+# @type var xs: Array[Integer]
 xs = TSort.tsort(each_node, each_child)

data/smoke/tsort/test_expectations.yml

@@ -1,63 +1 @@
----
-- file: a.rb
-  diagnostics:
-  - range:
-      start:
-        line: 7
-        character: 0
-      end:
-        line: 7
-        character: 38
-    severity: ERROR
-    message: |-
-      Cannot assign a value of type `^() -> ::Hash[::Integer, ::Array[::Integer]]` to a variable of type `^() { (::Integer) -> void } -> void`
-        ^() -> ::Hash[::Integer, ::Array[::Integer]] <: ^() { (::Integer) -> void } -> void
-    code: Ruby::IncompatibleAssignment
-  - range:
-      start:
-        line: 7
-        character: 34
-      end:
-        line: 7
-        character: 35
-    severity: ERROR
-    message: Cannot detect the type of the expression
-    code: Ruby::FallbackAny
-  - range:
-      start:
-        line: 9
-        character: 0
-      end:
-        line: 9
-        character: 41
-    severity: ERROR
-    message: |-
-      Cannot assign a value of type `^(::Integer) -> ::Enumerator[::Integer, ::Array[::Integer]]` to a variable of type `^(::Integer) { (::Integer) -> void } -> void`
-        ^(::Integer) -> ::Enumerator[::Integer, ::Array[::Integer]] <: ^(::Integer) { (::Integer) -> void } -> void
-    code: Ruby::IncompatibleAssignment
-  - range:
-      start:
-        line: 9
-        character: 37
-      end:
-        line: 9
-        character: 38
-    severity: ERROR
-    message: Cannot detect the type of the expression
-    code: Ruby::FallbackAny
-  - range:
-      start:
-        line: 12
-        character: 0
-      end:
-        line: 12
-        character: 39
-    severity: ERROR
-    message: |-
-      Cannot assign a value of type `::Array[::Integer]` to a variable of type `::Array[::String]`
-        ::Array[::Integer] <: ::Array[::String]
-          ::Integer <: ::String
-            ::Numeric <: ::String
-              ::Object <: ::String
-                ::BasicObject <: ::String
-    code: Ruby::IncompatibleAssignment
+--- []

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 0.48.0
+  version: 0.49.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-07 00:00:00.000000000 Z
+date: 2022-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser