steep 0.48.0 → 0.50.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72c3b61eccfe6a3f2cf2da22293bd7b50a001c25e82197b3efea52753857ff78
-  data.tar.gz: '08786e3140b0bbf10f79c5395a7026062abef6a690a9fefdf6ca464fbf13e92d'
+  metadata.gz: 6ff552f6d8f112693dc9969f20d851ddbc6d7d2f16cebd45f802a5d703618b58
+  data.tar.gz: 723464fe34c81c3e83b66338dfc6fd3e7c3da2aaf30c1fc48116c7de794ca961
 SHA512:
-  metadata.gz: d3abc0d6f64deffebf187428be69cec72dc5c887e0ecb2fbc407c20e2dde66bae8ce3bdf5f7f8a43ccaa90c562fa9c178bb9cc93a3d3d5b7fa99d5e7344fbfdd
-  data.tar.gz: df16f83cf33224f0442124546d3406313dff27bd472fc60978864c40cdffcbb9aa8013bb049c940021ccb6e76c7a1338d9d30fc0fb07f71e306e7dae21885ad7
+  metadata.gz: bf9f83791cfb636c65a26f404fb164fa7fc3906376e36a79a1ca4ae7eeab8020e23c5b9ce5e649a38ed79080d0aa2c00fe53a5cce8a1c76c259237f38880bbf2
+  data.tar.gz: 25bd9e11db283acdfc957682860e674d544b82be1b5a68bc87ca96888907966b721301c937cdaa3e06bf0226ec82fa8c78eacfaf4987637a601f75ca8d8e950c

data/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## master
 
+# 0.50.0 (2022-03-22)
+
+* CLI option for override steep command at spawn worker ([\#511](https://github.com/soutaro/steep/pull/511))
+* LSP related improvements for Sublime LSP ([\#513](https://github.com/soutaro/steep/pull/513))
+* Support Windows environment ([\#514](https://github.com/soutaro/steep/pull/514))
+* Let `&:foo` proc work with methods with optional parameters ([\#516](https://github.com/soutaro/steep/pull/516))
+* Fix unexpected error when or-asgn/and-asgn ([\#517](https://github.com/soutaro/steep/pull/517))
+* Fix goto-definition from method call inside block ([\#518](https://github.com/soutaro/steep/pull/518))
+* Better splat in array typing ([\#519](https://github.com/soutaro/steep/pull/519))
+
+## 0.49.1 (2022-03-11)
+
+* Fix lambda typing ([\#506](https://github.com/soutaro/steep/pull/506))
+* Validate type descendants ([\#507](https://github.com/soutaro/steep/pull/507))
+* Fix print error with absolute path ([\#508](https://github.com/soutaro/steep/pull/508))
+* Skip non-target ruby code on `steep stats` ([\#509](https://github.com/soutaro/steep/pull/509))
+
+## 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

@@ -9,4 +9,6 @@ gem "without_steep_types", path: "test/gems/without_steep_types"
 gem "rake"
 gem "minitest", "~> 5.15"
 gem "minitest-hooks"
-gem "stackprof"
+group :stackprof, optional: true do
+  gem "stackprof"
+end

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    steep (0.48.0)
+    steep (0.50.0)
       activesupport (>= 5.1)
       language_server-protocol (>= 3.15, < 4.0)
       listen (~> 3.0)
@@ -24,7 +24,7 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (7.0.2.2)
+    activesupport (7.0.2.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
@@ -41,7 +41,7 @@ GEM
     minitest (5.15.0)
     minitest-hooks (1.5.0)
       minitest (> 5.3)
-    parallel (1.21.0)
+    parallel (1.22.0)
     parser (3.1.1.0)
       ast (~> 2.4.1)
     rainbow (3.1.1)

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

@@ -72,6 +72,11 @@ module Steep
       opts.on("-j N", "--jobs=N", "Specify the number of type check workers (defaults: #{default})") do |count|
         command.jobs_count = Integer(count) if Integer(count) > 0
       end
+
+      command.steep_command = "steep"
+      opts.on("--steep-command=COMMAND", "Specify command to exec Steep CLI for worker (defaults: steep)") do |cmd|
+        command.steep_command = cmd
+      end
     end
 
     def process_init

data/lib/steep/diagnostic/ruby.rb

@@ -669,6 +669,19 @@ module Steep
         end
       end
 
+      class ProcTypeExpected < Base
+        attr_reader :type
+
+        def initialize(node:, type:)
+          super(node: node)
+          @type = type
+        end
+
+        def header_line
+          "Proc type is expected but `#{type.to_s}` is specified"
+        end
+      end
+
       class UnsupportedSyntax < Base
         attr_reader :message
 

data/lib/steep/drivers/check.rb

@@ -39,6 +39,7 @@ module Steep
           steepfile: project.steepfile_path,
           args: command_line_patterns,
           delay_shutdown: true,
+          steep_command: steep_command,
           count: jobs_count
         )
 
@@ -214,8 +215,8 @@ module Steep
           total = errors.sum {|notification| notification[:diagnostics].size }
 
           errors.each do |notification|
-            path = project.relative_path(Pathname(URI.parse(notification[:uri]).path))
-            buffer = RBS::Buffer.new(name: path, content: path.read)
+            path = Pathname(URI.parse(notification[:uri]).path)
+            buffer = RBS::Buffer.new(name: project.relative_path(path), content: path.read)
             printer = DiagnosticPrinter.new(buffer: buffer, stdout: stdout)
 
             notification[:diagnostics].each do |diag|

data/lib/steep/drivers/langserver.rb

@@ -37,8 +37,8 @@ module Steep
       def run
         @project = load_config()
 
-        interaction_worker = Server::WorkerProcess.spawn_worker(:interaction, name: "interaction", steepfile: project.steepfile_path)
-        typecheck_workers = Server::WorkerProcess.spawn_typecheck_workers(steepfile: project.steepfile_path, args: [], count: jobs_count)
+        interaction_worker = Server::WorkerProcess.spawn_worker(:interaction, name: "interaction", steepfile: project.steepfile_path, steep_command: steep_command)
+        typecheck_workers = Server::WorkerProcess.spawn_typecheck_workers(steepfile: project.steepfile_path, args: [], steep_command: steep_command, count: jobs_count)
 
         master = Server::Master.new(
           project: project,

data/lib/steep/drivers/stats.rb

@@ -129,6 +129,7 @@ module Steep
           steepfile: project.steepfile_path,
           delay_shutdown: true,
           args: command_line_patterns,
+          steep_command: steep_command,
           count: jobs_count
         )
 

data/lib/steep/drivers/utils/jobs_count.rb

@@ -2,7 +2,7 @@ module Steep
   module Drivers
     module Utils
       module JobsCount
-        attr_accessor :jobs_count
+        attr_accessor :jobs_count, :steep_command
       end
     end
   end

data/lib/steep/drivers/watch.rb

@@ -41,7 +41,7 @@ module Steep
         server_reader = LanguageServer::Protocol::Transport::Io::Reader.new(server_read)
         server_writer = LanguageServer::Protocol::Transport::Io::Writer.new(server_write)
 
-        typecheck_workers = Server::WorkerProcess.spawn_typecheck_workers(steepfile: project.steepfile_path, args: dirs.map(&:to_s), count: jobs_count)
+        typecheck_workers = Server::WorkerProcess.spawn_typecheck_workers(steepfile: project.steepfile_path, args: dirs.map(&:to_s), steep_command: steep_command, count: jobs_count)
 
         master = Server::Master.new(
           project: project,

data/lib/steep/interface/function.rb

@@ -879,6 +879,11 @@ module Steep
           !has_positional? && !has_keywords?
         end
 
+        # Returns true if all arguments are non-required.
+        def optional?
+          required.empty? && required_keywords.empty?
+        end
+
         # self + params returns a new params for overloading.
         #
         def +(other)
@@ -952,6 +957,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/project.rb

@@ -16,7 +16,21 @@ module Steep
       steepfile_path.parent
     end
 
-    def relative_path(path)
+    def relative_path(orig_path)
+      path = if Gem.win_platform?
+               path_str = URI.decode_www_form_component(
+                 orig_path.to_s.delete_prefix("/")
+               )
+               unless path_str.start_with?(%r{[a-z]:/}i)
+                 # FIXME: Sometimes drive letter is missing, taking from base_dir
+                 path_str = base_dir.to_s.split("/")[0] + "/" + path_str
+               end
+               Pathname.new(
+                 path_str
+               )
+             else
+               orig_path
+             end
       path.relative_path_from(base_dir)
     end
 

data/lib/steep/server/interaction_worker.rb

@@ -89,7 +89,7 @@ module Steep
               end
 
               LSP::Interface::Hover.new(
-                contents: { kind: "markdown", value: format_hover(content) },
+                contents: { kind: "markdown", value: format_hover(content)&.gsub(/<!--(?~-->)-->/, "") },
                 range: range
               )
             end
@@ -271,7 +271,7 @@ HOVER
           ),
           end: LanguageServer::Protocol::Interface::Position.new(
             line: job.line - 1,
-            character: job.column - prefix.size
+            character: job.column
           )
         )
 

data/lib/steep/server/master.rb

@@ -49,9 +49,14 @@ module Steep
         end
 
         def checking_path?(path)
-          library_paths.include?(path) ||
-            signature_paths.include?(path) ||
-            code_paths.include?(path)
+          [library_paths, signature_paths, code_paths].any? do |paths|
+            if Gem.win_platform?
+              # FIXME: Sometimes drive letter is missing, so comparing without drive letter.
+              paths.any? {|p| p.to_s.split("/", 2)[1] == path.to_s.split("/", 2)[1]}
+            else
+              paths.include?(path)
+            end
+          end
         end
 
         def checked(path)
@@ -739,7 +744,7 @@ module Steep
                       { kind: "end" }
                     else
                       progress_string = ("▮"*(percentage/5)) + ("▯"*(20 - percentage/5))
-                      { kind: "report", percentage: percentage, message: "#{progress_string} (#{percentage}%)" }
+                      { kind: "report", percentage: percentage, message: "#{progress_string}" }
                     end
 
             job_queue << SendMessageJob.to_client(

data/lib/steep/server/type_check_worker.rb

@@ -135,6 +135,21 @@ module Steep
       end
 
       def handle_job(job)
+        job_path = if job.respond_to?(:path)
+                     if Gem.win_platform?
+                       # FIXME: Sometimes drive letter is missing, using base_dir
+                       if job.path.to_s.start_with?(%r{/[a-z](:|%3A)/}i)
+                         job.path.to_s
+                       else
+                         "/#{project.base_dir.to_s.split("/").first}/#{job.path}"
+                       end
+                     else
+                       job.path.to_s
+                     end
+                   else
+                     nil
+                   end
+
         case job
         when StartTypeCheckJob
           Steep.logger.info { "Processing StartTypeCheckJob for guid=#{job.guid}" }
@@ -149,7 +164,7 @@ module Steep
               writer.write(
                 method: :"textDocument/publishDiagnostics",
                 params: LSP::Interface::PublishDiagnosticsParams.new(
-                  uri: URI.parse(job.path.to_s).tap {|uri| uri.scheme = "file"},
+                  uri: URI.parse(job_path).tap {|uri| uri.scheme = "file"},
                   diagnostics: diagnostics.map {|diagnostic| formatter.format(diagnostic) }.uniq
                 )
               )
@@ -167,7 +182,7 @@ module Steep
               writer.write(
                 method: :"textDocument/publishDiagnostics",
                 params: LSP::Interface::PublishDiagnosticsParams.new(
-                  uri: URI.parse(job.path.to_s).tap {|uri| uri.scheme = "file"},
+                  uri: URI.parse(job_path).tap {|uri| uri.scheme = "file"},
                   diagnostics: diagnostics.map {|diagnostic| formatter.format(diagnostic) }.uniq.compact
                 )
               )
@@ -186,7 +201,7 @@ module Steep
               writer.write(
                 method: :"textDocument/publishDiagnostics",
                 params: LSP::Interface::PublishDiagnosticsParams.new(
-                  uri: URI.parse(job.path.to_s).tap {|uri| uri.scheme = "file"},
+                  uri: URI.parse(job_path).tap {|uri| uri.scheme = "file"},
                   diagnostics: diagnostics.map {|diagnostic| formatter.format(diagnostic) }.uniq.compact
                 )
               )
@@ -268,7 +283,7 @@ module Steep
         line = job.params[:position][:line] + 1
         column = job.params[:position][:character]
 
-        goto_service = Services::GotoService.new(type_check: service)
+        goto_service = Services::GotoService.new(type_check: service, assignment: assignment)
         locations =
           case
           when job.definition?

data/lib/steep/server/worker_process.rb

@@ -18,13 +18,17 @@ module Steep
         @index = index
       end
 
-      def self.spawn_worker(type, name:, steepfile:, options: [], delay_shutdown: false, index: nil)
-        log_level = %w(debug info warn error fatal unknown)[Steep.logger.level]
+      def self.spawn_worker(type, name:, steepfile:, steep_command: "steep", options: [], delay_shutdown: false, index: nil)
+        args = ["--name=#{name}", "--steepfile=#{steepfile}"]
+        args << (%w(debug info warn error fatal unknown)[Steep.logger.level].yield_self {|log_level| "--log-level=#{log_level}" })
+        if Steep.log_output.is_a?(String)
+          args << "--log-output=#{Steep.log_output}"
+        end
         command = case type
                   when :interaction
-                    ["steep", "worker", "--interaction", "--name=#{name}", "--log-level=#{log_level}", "--steepfile=#{steepfile}", *options]
+                    [steep_command, "worker", "--interaction", *args, *options]
                   when :typecheck
-                    ["steep", "worker", "--typecheck", "--name=#{name}", "--log-level=#{log_level}", "--steepfile=#{steepfile}", *options]
+                    [steep_command, "worker", "--typecheck", *args, *options]
                   else
                     raise "Unknown type: #{type}"
                   end
@@ -33,7 +37,11 @@ module Steep
           command << "--delay-shutdown"
         end
 
-        stdin, stdout, thread = Open3.popen2(*command, pgroup: true)
+        stdin, stdout, thread = if Gem.win_platform?
+                                  Open3.popen2(*command, new_pgroup: true)
+                                else
+                                  Open3.popen2(*command, pgroup: true)
+                                end
         stderr = nil
 
         writer = LanguageServer::Protocol::Transport::Io::Writer.new(stdin)
@@ -42,11 +50,12 @@ module Steep
         new(reader: reader, writer: writer, stderr: stderr, wait_thread: thread, name: name, index: index)
       end
 
-      def self.spawn_typecheck_workers(steepfile:, args:, count: [Etc.nprocessors - 1, 1].max, delay_shutdown: false)
+      def self.spawn_typecheck_workers(steepfile:, args:, steep_command: "steep", count: [Etc.nprocessors - 1, 1].max, delay_shutdown: false)
         count.times.map do |i|
           spawn_worker(:typecheck,
                        name: "typecheck@#{i}",
                        steepfile: steepfile,
+                       steep_command: steep_command,
                        options: ["--max-index=#{count}", "--index=#{i}", *args],
                        delay_shutdown: delay_shutdown,
                        index: i)

data/lib/steep/services/goto_service.rb

@@ -21,10 +21,11 @@ module Steep
       end
       TypeNameQuery = Struct.new(:name, keyword_init: true)
 
-      attr_reader :type_check
+      attr_reader :type_check, :assignment
 
-      def initialize(type_check:)
+      def initialize(type_check:, assignment:)
         @type_check = type_check
+        @assignment = assignment
       end
 
       def project
@@ -78,7 +79,17 @@ module Steep
           end
         end
 
-        locations.uniq
+        # Drop un-assigned paths here.
+        # The path assignment makes sense only for `.rbs` files, because un-assigned `.rb` files are already skipped since they are not type checked.
+        #
+        locations.uniq.select do |loc|
+          case loc
+          when RBS::Location
+            assignment =~ loc.name
+          else
+            true
+          end
+        end
       end
 
       def test_ast_location(loc, line:, column:)
@@ -100,6 +111,7 @@ module Steep
           typing, signature = type_check_path(target: target, path: relative_path, content: source.content, line: line, column: column)
           if typing
             node, *parents = typing.source.find_nodes(line: line, column: column)
+
             if node
               case node.type
               when :const, :casgn
@@ -125,7 +137,10 @@ module Steep
                 end
               when :send
                 if test_ast_location(node.location.selector, line: line, column: column)
-                  node = parents[0] if parents[0]&.type == :block
+                  if (parent = parents[0]) && parent.type == :block && parent.children[0] == node
+                    node = parents[0]
+                  end
+
                   case call = typing.call_of(node: node)
                   when TypeInference::MethodCall::Typed, TypeInference::MethodCall::Error
                     call.method_decls.each do |decl|

data/lib/steep/services/type_check_service.rb

@@ -269,6 +269,8 @@ module Steep
       end
 
       def typecheck_source(path:, target: project.target_for_source_path(path), &block)
+        return unless target
+
         Steep.logger.tagged "#typecheck_source(path=#{path})" do
           Steep.measure "typecheck" do
             signature_service = signature_services[target.name]

data/lib/steep/signature/validator.rb

@@ -89,11 +89,7 @@ module Steep
         end
       end
 
-      def validate_type(type)
-        Steep.logger.debug "#{Location.to_string type.location}: Validating #{type}..."
-
-        validator.validate_type type, context: [RBS::Namespace.root]
-
+      def validate_type_application(type)
         name, type_params, type_args =
           case type
           when RBS::Types::ClassInstance
@@ -123,6 +119,17 @@ module Steep
             validate_type_application_constraints(type.name, type_params, type_args, location: type.location)
           end
         end
+
+        type.each_type do |child|
+          validate_type_application(child)
+        end
+      end
+
+      def validate_type(type)
+        Steep.logger.debug "#{Location.to_string type.location}: Validating #{type}..."
+
+        validator.validate_type type, context: [RBS::Namespace.root]
+        validate_type_application(type)
       end
 
       def ancestor_to_type(ancestor)

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
@@ -2272,13 +2275,10 @@ module Steep
               type, constr = synthesize(rhs, hint: hint)
               constr.ivasgn(asgn, type)
             when :send
-              rhs_ = node.updated(:send,
-                                  [
-                                    asgn.children[0],
-                                    :"#{asgn.children[1]}=",
-                                    asgn.children[2],
-                                    rhs
-                                  ])
+              children = asgn.children.dup
+              children[1] = :"#{children[1]}="
+              send_arg_nodes = [*children, rhs]
+              rhs_ = node.updated(:send, send_arg_nodes)
               node_type = case node.type
                           when :or_asgn
                             :or
@@ -2345,11 +2345,11 @@ module Steep
                   interface = calculate_interface(param_type, private: true)
                   method = interface.methods[value.children[0]]
                   if method
-                    return_types = method.method_types.select {|method_type|
-                      method_type.type.params.empty?
-                    }.map {|method_type|
-                      method_type.type.return_type
-                    }
+                    return_types = method.method_types.filter_map do |method_type|
+                      if method_type.type.params.optional?
+                        method_type.type.return_type
+                      end
+                    end
 
                     unless return_types.empty?
                       type = AST::Types::Proc.new(
@@ -2357,7 +2357,7 @@ module Steep
                           params: Interface::Function::Params.empty.with_first_param(
                             Interface::Function::Params::PositionalParams::Required.new(param_type)
                           ),
-                          return_type: AST::Types::Union.build(types: return_types),
+                          return_type: return_types[0],
                           location: nil
                         ),
                         block: nil
@@ -2724,34 +2724,89 @@ module Steep
       end
     end
 
-    def type_lambda(node, block_params:, block_body:, type_hint:)
+    def optional_proc?(type)
+      if type.is_a?(AST::Types::Union)
+        if type.types.size == 2
+          if type.types.find {|t| t.is_a?(AST::Types::Nil) }
+            if proc_type = type.types.find {|t| t.is_a?(AST::Types::Proc) }
+              proc_type
+            end
+          end
+        end
+      end
+    end
+
+    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)
+
+      type_hint = deep_expand_alias(type_hint) if type_hint
 
       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
       )
 
       block_constr.typing.add_context_for_body(node, context: block_constr.context)
 
+      default_proc_function =
+        Interface::Function.new(
+          params: Interface::Function::Params.empty,
+          return_type: AST::Builtin.any_type,
+          location: nil
+        )
+
       params.params.each do |param|
         _, 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)
+            else
+              if proc_type = optional_proc?(block_param_type)
+                Interface::Block.new(type: proc_type.type, optional: true)
+              else
+                block_constr.typing.add_error(
+                  Diagnostic::Ruby::ProcTypeExpected.new(
+                    node: block_param.node,
+                    type: block_param_type
+                  )
+                )
+
+                Interface::Block.new(
+                  type: Interface::Function.new(
+                    params: Interface::Function::Params.empty,
+                    return_type: AST::Builtin.any_type,
+                    location: nil
+                  ),
+                  optional: false
+                )
+              end
+            end
+          else
+            block_hint
+          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 +2834,7 @@ module Steep
           return_type: return_type,
           location: nil
         ),
-        block: nil
+        block: block
       )
 
       add_typing node, type: block_type
@@ -3246,7 +3301,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 +3309,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 +3559,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 +3593,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
@@ -3888,6 +3945,20 @@ module Steep
       constr.add_typing(node, type: AST::Types::Tuple.new(types: element_types))
     end
 
+    def try_convert(type, method)
+      interface = checker.factory.interface(type, private: false)
+      if entry = interface.methods[method]
+        method_type = entry.method_types.find do |method_type|
+          method_type.type.params.optional?
+        end
+
+        method_type.type.return_type
+      end
+    rescue => exn
+      Steep.log_error(exn, message: "Unexpected error when converting #{type.to_s} with #{method}")
+      nil
+    end
+
     def try_array_type(node, hint)
       element_hint = hint ? hint.args[0] : nil
 
@@ -3898,8 +3969,14 @@ module Steep
         case child.type
         when :splat
           type, constr = constr.synthesize(child.children[0], hint: hint)
-          if AST::Builtin::Array.instance_type?(type)
+
+          type = try_convert(type, :to_a) || type
+
+          case
+          when AST::Builtin::Array.instance_type?(type)
             element_types << type.args[0]
+          when type.is_a?(AST::Types::Tuple)
+            element_types.push(*type.types)
           else
             element_types.push(*flatten_array_elements(type))
           end

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.50.0"
 end

data/smoke/diagnostics/proc_type_expected.rb

@@ -0,0 +1,3 @@
+-> (&block) do
+  # @type var block: Integer
+end

data/smoke/diagnostics/test_expectations.yml

@@ -332,6 +332,18 @@
     severity: ERROR
     message: Type `::Integer` does not have method `foo`
     code: Ruby::NoMethod
+- file: proc_type_expected.rb
+  diagnostics:
+  - range:
+      start:
+        line: 1
+        character: 4
+      end:
+        line: 1
+        character: 10
+    severity: ERROR
+    message: Proc type is expected but `::Integer` is specified
+    code: Ruby::ProcTypeExpected
 - file: required_block_missing.rb
   diagnostics:
   - range:

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.50.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-07 00:00:00.000000000 Z
+date: 2022-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -356,6 +356,7 @@ files:
 - smoke/diagnostics/method_return_type_annotation_mismatch.rb
 - smoke/diagnostics/missing_keyword.rb
 - smoke/diagnostics/no_method.rb
+- smoke/diagnostics/proc_type_expected.rb
 - smoke/diagnostics/required_block_missing.rb
 - smoke/diagnostics/return_type_mismatch.rb
 - smoke/diagnostics/test_expectations.yml