steep 0.52.0 → 0.52.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6846cc048d7515ef655b81cf7f399e5852a96c390d90c7f859c07cc6a5c0f94
-  data.tar.gz: fecb8b0b0be4e338f3ccf0375064f39167693c0b25b68e3b4ea2f103f117260f
+  metadata.gz: c373c6a4366397b2b014850a8993ce6d8a0c27bcdd8bc8c5135bb64b4132b162
+  data.tar.gz: '097245d5e3745ceb634a2f2bcd007cca0c549449c835b644feb62c23c3c6e3ed'
 SHA512:
-  metadata.gz: 9c08fa692eda8915ef4ce4fe725aecb2a9823c2da188900a3811fdf1d02c6b0369dae8755aed83fe9cc80a376c3309df29efcf849681cd2a9a249559ff6c3ae2
-  data.tar.gz: 77953f34eb6ab001dfee4f03e0ec1250f1128fedae9e5b427e0037b97b6b809c5bb8ae4c94d9d93f3af3a702de7dd33a182399fe2b7a81ba8ac0d2708c422579
+  metadata.gz: eadc49c7c81bce14e4e4c5f9adbcb0411669cd1f78eb290029953e26ea3997d15a65db53329124812e841f3fbe486d30f25bbf89d7bce74d528692176250c795
+  data.tar.gz: 3257fa14e2888e68afd6266e1c1d28dc95b8ef7e1ec499393994f35cb715abfc133f005d0ce79962fc6642f7fdeb0b28c35fa0d3bb5687972ea1b31d0a9d6c38

data/.github/dependabot.yml

@@ -1,8 +1,15 @@
 version: 2
+
 updates:
-- package-ecosystem: bundler
-  directory: "/"
-  schedule:
-    interval: daily
-    time: "20:00"
-  open-pull-requests-limit: 10
+  - package-ecosystem: bundler
+    directory: "/"
+    schedule:
+      interval: daily
+      time: "20:00"
+    open-pull-requests-limit: 10
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      # Check for updates to GitHub Actions every weekday
+      interval: "daily"

data/.github/workflows/ruby.yml

@@ -14,6 +14,7 @@ jobs:
         container_tag:
         - "2.7"
         - "3.0"
+        - "3.1"
         - "master-nightly-focal"
         task:
         - test
@@ -22,9 +23,10 @@ jobs:
     container:
       image: rubylang/ruby:${{ matrix.container_tag }}
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v3
     - name: Run test
       run: |
+        git config --global --add safe.directory /__w/steep/steep
         ruby -v
         gem install bundler
         bundle install --jobs 4 --retry 3

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## master
 
+## 0.52.1 (2022-04-25)
+
+* Better union type inference (it type checks `Array#filter_map` now!) ([\#531](https://github.com/soutaro/steep/pull/531))
+* Improve method call hover message ([\#537](https://github.com/soutaro/steep/pull/537), [\#538](https://github.com/soutaro/steep/pull/538))
+* Make `NilClass#!` a special method to improve flow-sensitive typing ([\#539](https://github.com/soutaro/steep/pull/539))
+* Fix `steep binstub` ([\#540](https://github.com/soutaro/steep/pull/540), [\#541](https://github.com/soutaro/steep/pull/541))
+
 ## 0.52.0 (2022-04-05)
 
 * Add `steep binstub` command ([\#527](https://github.com/soutaro/steep/pull/527))

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    steep (0.52.0)
+    steep (0.52.1)
       activesupport (>= 5.1)
       language_server-protocol (>= 3.15, < 4.0)
       listen (~> 3.0)
       parallel (>= 1.0.0)
       parser (>= 3.0)
       rainbow (>= 2.2.2, < 4.0)
-      rbs (>= 2.3.0)
+      rbs (>= 2.3.2)
       terminal-table (>= 2, < 4)
 
 PATH
@@ -44,14 +44,14 @@ GEM
     minitest-slow_test (0.2.0)
       minitest (>= 5.0)
     parallel (1.22.1)
-    parser (3.1.1.0)
+    parser (3.1.2.0)
       ast (~> 2.4.1)
     rainbow (3.1.1)
     rake (13.0.6)
     rb-fsevent (0.11.1)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rbs (2.3.1)
+    rbs (2.3.2)
     stackprof (0.2.19)
     terminal-table (3.0.2)
       unicode-display_width (>= 1.1.1, < 3)

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

@@ -431,7 +431,8 @@ module Steep
               case defined_in
               when RBS::BuiltinNames::BasicObject.name,
                 RBS::BuiltinNames::TrueClass.name,
-                RBS::BuiltinNames::FalseClass.name
+                RBS::BuiltinNames::FalseClass.name,
+                AST::Builtin::NilClass.module_name
                 return method_type.with(
                   type: method_type.type.with(
                     return_type: AST::Types::Logic::Not.new(location: method_type.type.return_type.location)

data/lib/steep/cli.rb

@@ -210,6 +210,7 @@ module Steep
 
     def process_binstub
       path = Pathname("bin/steep")
+      root_path = Pathname.pwd
       force = false
 
       OptionParser.new do |opts|
@@ -227,21 +228,28 @@ BANNER
           path = Pathname(v)
         end
 
+        opts.on("--root=PATH", "The repository root path (defaults to `.`)") do |v|
+          root_path = (Pathname.pwd + v).cleanpath
+        end
+
         opts.on("--[no-]force", "Overwrite file (defaults to false)") do
           force = true
         end
       end.parse!(argv)
 
-      path.parent.mkpath
+      binstub_path = (Pathname.pwd + path).cleanpath
+      bindir_path = binstub_path.parent
+
+      bindir_path.mkpath
 
       gemfile_path =
         if defined?(Bundler)
-          Bundler.default_gemfile.relative_path_from(Pathname.pwd + path.parent)
+          Bundler.default_gemfile.relative_path_from(bindir_path)
         else
           Pathname("../Gemfile")
         end
 
-      if path.file?
+      if binstub_path.file?
         if force
           stdout.puts Rainbow("#{path} already exists. Overwriting...").yellow
         else
@@ -254,7 +262,8 @@ BANNER
 #!/usr/bin/env bash
 
 BINSTUB_DIR=$(cd $(dirname $0); pwd)
-GEMFILE=${BINSTUB_DIR}/#{gemfile_path}
+GEMFILE=$(readlink -f ${BINSTUB_DIR}/#{gemfile_path})
+ROOT_DIR=$(readlink -f ${BINSTUB_DIR}/#{root_path.relative_path_from(bindir_path)})
 
 STEEP="bundle exec --gemfile=${GEMFILE} steep"
 
@@ -262,15 +271,15 @@ if type "rbenv" > /dev/null 2>&1; then
   STEEP="rbenv exec ${STEEP}"
 else
   if type "rvm" > /dev/null 2>&1; then
-    STEEP="rvm ${REPO_ROOT} do ${STEEP}"
+    STEEP="rvm ${ROOT_DIR} do ${STEEP}"
   fi
 fi
 
 exec $STEEP $@
 TEMPLATE
 
-      path.write(template)
-      path.chmod(0755)
+      binstub_path.write(template)
+      binstub_path.chmod(0755)
 
       stdout.puts Rainbow("Successfully generated executable #{path} 🎉").blue
 

data/lib/steep/server/interaction_worker.rb

@@ -78,8 +78,7 @@ module Steep
           Steep.measure "Generating hover response" do
             Steep.logger.info { "path=#{job.path}, line=#{job.line}, column=#{job.column}" }
 
-            hover = Services::HoverContent.new(service: service)
-            content = hover.content_for(path: job.path, line: job.line, column: job.column)
+            content = Services::HoverProvider.content_for(service: service, path: job.path, line: job.line, column: job.column)
             if content
               range = content.location.yield_self do |location|
                 lsp_range = location.as_lsp_range
@@ -89,7 +88,10 @@ module Steep
               end
 
               LSP::Interface::Hover.new(
-                contents: { kind: "markdown", value: format_hover(content)&.gsub(/<!--(?~-->)-->/, "") },
+                contents: {
+                  kind: "markdown",
+                  value: LSPFormatter.format_hover_content(content).to_s
+                },
                 range: range
               )
             end
@@ -100,101 +102,6 @@ module Steep
         end
       end
 
-      def format_hover(content)
-        case content
-        when Services::HoverContent::TypeAliasContent
-          comment = content.decl.comment&.string || ''
-
-          <<-MD
-#{comment}
-
-```rbs
-#{retrieve_decl_information(content.decl)}
-```
-          MD
-        when Services::HoverContent::InterfaceContent
-          comment = content.decl.comment&.string || ''
-
-          <<-MD
-#{comment}
-
-```rbs
-#{retrieve_decl_information(content.decl)}
-```
-          MD
-        when Services::HoverContent::ClassContent
-          comment = content.decl.comment&.string || ''
-
-          <<-MD
-#{comment}
-
-```rbs
-#{retrieve_decl_information(content.decl)}
-```
-          MD
-        when Services::HoverContent::VariableContent
-          "`#{content.name}`: `#{content.type.to_s}`"
-        when Services::HoverContent::MethodCallContent
-          method_name = case content.method_name
-                        when Services::HoverContent::InstanceMethodName
-                          "#{content.method_name.class_name}##{content.method_name.method_name}"
-                        when Services::HoverContent::SingletonMethodName
-                          "#{content.method_name.class_name}.#{content.method_name.method_name}"
-                        else
-                          nil
-                        end
-
-          if method_name
-            string = <<HOVER
-```
-#{method_name} ~> #{content.type}
-```
-HOVER
-            if content.definition
-              if content.definition.comments
-                string << "\n----\n\n#{content.definition.comments.map(&:string).join("\n\n")}"
-              end
-
-              string << "\n----\n\n#{content.definition.method_types.map {|x| "- `#{x}`\n" }.join()}"
-            end
-          else
-            "`#{content.type}`"
-          end
-        when Services::HoverContent::DefinitionContent
-          string = <<HOVER
-```
-def #{content.method_name}: #{content.method_type}
-```
-HOVER
-          if (comment = content.comment_string)
-            string << "\n----\n\n#{comment}\n"
-          end
-
-          if content.definition.method_types.size > 1
-            string << "\n----\n\n#{content.definition.method_types.map {|x| "- `#{x}`\n" }.join()}"
-          end
-
-          string
-        when Services::HoverContent::ConstantContent
-          ss = []
-          if content.class_or_module?
-            ss << ["```rbs", retrieve_decl_information(content.decl.primary.decl), "```"].join("\n")
-          end
-
-          if content.constant?
-            ss << ["```rbs", "#{content.full_name}: #{content.type}", "```"].join("\n")
-          end
-
-          if s = content.comment_string
-            ss << s
-          end
-
-          ss.join("\n\n----\n\n")
-        when Services::HoverContent::TypeContent
-          "`#{content.type}`"
-        end
-      end
-
       def process_completion(job)
         Steep.logger.tagged("#response_to_completion") do
           Steep.measure "Generating response" do
@@ -356,59 +263,6 @@ HOVER
         end
       end
 
-      def name_and_params(name, params)
-        if params.empty?
-          "#{name}"
-        else
-          ps = params.each.map do |param|
-            s = ""
-            if param.unchecked?
-              s << "unchecked "
-            end
-            case param.variance
-            when :invariant
-              # nop
-            when :covariant
-              s << "out "
-            when :contravariant
-              s << "in "
-            end
-            s + param.name.to_s
-          end
-
-          "#{name}[#{ps.join(", ")}]"
-        end
-      end
-
-      def name_and_args(name, args)
-        if name && args
-          if args.empty?
-            "#{name}"
-          else
-            "#{name}[#{args.join(", ")}]"
-          end
-        end
-      end
-
-      def retrieve_decl_information(decl)
-        case decl
-        when RBS::AST::Declarations::Class
-          super_class = if super_class = decl.super_class
-                          " < #{name_and_args(super_class.name, super_class.args)}"
-                        end
-          "class #{name_and_params(decl.name, decl.type_params)}#{super_class}"
-        when RBS::AST::Declarations::Module
-          self_type = unless decl.self_types.empty?
-                        " : #{decl.self_types.join(", ")}"
-                      end
-          "module #{name_and_params(decl.name, decl.type_params)}#{self_type}"
-        when RBS::AST::Declarations::Alias
-          "type #{decl.name} = #{decl.type}"
-        when RBS::AST::Declarations::Interface
-          "interface #{name_and_params(decl.name, decl.type_params)}"
-        end
-      end
-
       def format_completion_item(item)
         range = LanguageServer::Protocol::Interface::Range.new(
           start: LanguageServer::Protocol::Interface::Position.new(

data/lib/steep/server/lsp_formatter.rb

@@ -0,0 +1,234 @@
+module Steep
+  module Server
+    module LSPFormatter
+      include Services
+
+      class CommentBuilder
+        def initialize
+          @array = []
+        end
+
+        def self.build
+          builder = CommentBuilder.new
+          yield builder
+          builder.to_s
+        end
+
+        def to_s
+          unless @array.empty?
+            @array.join("\n\n----\n\n")
+          end
+        end
+
+        def <<(string)
+          if string
+            s = string.rstrip.gsub(/^[ \t]*<!--(?~-->)-->\n/, "").gsub(/\A([ \t]*\n)+/, "")
+            unless @array.include?(s)
+              @array << s
+            end
+          end
+        end
+
+        def push
+          s = ""
+          yield s
+          self << s
+        end
+      end
+
+      module_function
+
+      def format_hover_content(content)
+        case content
+        when HoverProvider::Ruby::VariableContent
+          "`#{content.name}`: `#{content.type.to_s}`"
+
+        when HoverProvider::Ruby::MethodCallContent
+          CommentBuilder.build do |builder|
+            call = content.method_call
+            builder.push do |s|
+              case call
+              when TypeInference::MethodCall::Typed
+                mt = call.actual_method_type.with(
+                  type: call.actual_method_type.type.with(return_type: call.return_type)
+                )
+                s << "```rbs\n#{mt.to_s}\n```\n\n"
+              when TypeInference::MethodCall::Error
+                s << "```rbs\n( ??? ) -> #{call.return_type.to_s}\n```\n\n"
+              end
+
+              s << to_list(call.method_decls) do |decl|
+                "`#{decl.method_name}`"
+              end
+            end
+
+            call.method_decls.each do |decl|
+              if comment = decl.method_def.comment
+                builder << <<EOM
+**#{decl.method_name.to_s}**
+
+```rbs
+#{decl.method_type}
+```
+
+#{decl.method_def.comment.string.gsub(/\A([ \t]*\n)+/, "")}
+EOM
+              end
+            end
+          end
+
+        when HoverProvider::Ruby::DefinitionContent
+          CommentBuilder.build do |builder|
+            builder << <<EOM
+```
+#{content.method_name}: #{content.method_type}
+```
+EOM
+            if comments = content.definition&.comments
+              comments.each do |comment|
+                builder << comment.string
+              end
+            end
+
+            if content.definition.method_types.size > 1
+              builder << to_list(content.definition.method_types) {|type| "`#{type.to_s}`" }
+            end
+          end
+        when HoverProvider::Ruby::ConstantContent
+          CommentBuilder.build do |builder|
+            if content.class_or_module?
+              builder << <<EOM
+```rbs
+#{declaration_summary(content.decl.primary.decl)}
+```
+EOM
+            end
+
+            if content.constant?
+              builder << <<EOM
+```rbs
+#{content.full_name}: #{content.type}
+```
+EOM
+            end
+
+            content.comments.each do |comment|
+              builder << comment.string
+            end
+          end
+        when HoverProvider::Ruby::TypeContent
+          "`#{content.type}`"
+        when HoverProvider::RBS::TypeAliasContent
+          CommentBuilder.build do |builder|
+            builder << <<EOM
+```rbs
+#{declaration_summary(content.decl)}
+```
+EOM
+            if comment = content.decl.comment
+              builder << comment.string
+            end
+          end
+        when HoverProvider::RBS::ClassContent
+          CommentBuilder.build do |builder|
+            builder << <<EOM
+```rbs
+#{declaration_summary(content.decl)}
+```
+EOM
+            if comment = content.decl.comment
+              builder << comment.string
+            end
+          end
+        when HoverProvider::RBS::InterfaceContent
+          CommentBuilder.build do |builder|
+            builder << <<EOM
+```rbs
+#{declaration_summary(content.decl)}
+```
+EOM
+            if comment = content.decl.comment
+              builder << comment.string
+            end
+          end
+        else
+          raise content.class.to_s
+        end
+      end
+
+      def to_list(collection, &block)
+        buffer = ""
+
+        strings =
+          if block
+            collection.map(&block)
+          else
+            collection.map(&:to_s)
+          end
+
+        strings.each do |s|
+          buffer << "- #{s}\n"
+        end
+
+        buffer
+      end
+
+      def name_and_args(name, args)
+        if args.empty?
+          "#{name}"
+        else
+          "#{name}[#{args.map(&:to_s).join(", ")}]"
+        end
+      end
+
+      def name_and_params(name, params)
+        if params.empty?
+          "#{name}"
+        else
+          ps = params.each.map do |param|
+            s = ""
+            if param.unchecked?
+              s << "unchecked "
+            end
+            case param.variance
+            when :invariant
+              # nop
+            when :covariant
+              s << "out "
+            when :contravariant
+              s << "in "
+            end
+            s << param.name.to_s
+
+            if param.upper_bound
+              s << " < #{param.upper_bound.to_s}"
+            end
+
+            s
+          end
+
+          "#{name}[#{ps.join(", ")}]"
+        end
+      end
+
+      def declaration_summary(decl)
+        case decl
+        when RBS::AST::Declarations::Class
+          super_class = if super_class = decl.super_class
+                          " < #{name_and_args(super_class.name, super_class.args)}"
+                        end
+          "class #{name_and_params(decl.name, decl.type_params)}#{super_class}"
+        when RBS::AST::Declarations::Module
+          self_type = unless decl.self_types.empty?
+                        " : #{decl.self_types.map {|s| name_and_args(s.name, s.args) }.join(", ")}"
+                      end
+          "module #{name_and_params(decl.name, decl.type_params)}#{self_type}"
+        when RBS::AST::Declarations::Alias
+          "type #{decl.name} = #{decl.type}"
+        when RBS::AST::Declarations::Interface
+          "interface #{name_and_params(decl.name, decl.type_params)}"
+        end
+      end
+    end
+  end
+end

data/lib/steep/services/hover_provider/rbs.rb

@@ -0,0 +1,63 @@
+module Steep
+  module Services
+    module HoverProvider
+      class RBS
+        TypeAliasContent = Struct.new(:location, :decl, keyword_init: true)
+        ClassContent = Struct.new(:location, :decl, keyword_init: true)
+        InterfaceContent = Struct.new(:location, :decl, keyword_init: true)
+
+        attr_reader :service
+
+        def initialize(service:)
+          @service = service
+        end
+
+        def project
+          service.project
+        end
+
+        def content_for(target:, path:, line:, column:)
+          service = self.service.signature_services[target.name]
+
+          _, decls = service.latest_env.buffers_decls.find do |buffer, _|
+            Pathname(buffer.name) == path
+          end
+
+          return if decls.nil?
+
+          loc_key, path = ::RBS::Locator.new(decls: decls).find2(line: line, column: column) || return
+          head, *tail = path
+
+          case head
+          when ::RBS::Types::Alias
+            alias_decl = service.latest_env.alias_decls[head.name]&.decl or raise
+
+            TypeAliasContent.new(
+              location: head.location,
+              decl: alias_decl
+            )
+          when ::RBS::Types::ClassInstance, ::RBS::Types::ClassSingleton
+            if loc_key == :name
+              env = service.latest_env
+              class_decl = env.class_decls[head.name]&.decls[0]&.decl or raise
+              location = head.location[:name]
+              ClassContent.new(
+                location: location,
+                decl: class_decl
+              )
+            end
+          when ::RBS::Types::Interface
+            env = service.latest_env
+            interface_decl = env.interface_decls[head.name]&.decl or raise
+            location = head.location[:name]
+
+            InterfaceContent.new(
+              location: location,
+              decl: interface_decl
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/services/hover_provider/ruby.rb

@@ -0,0 +1,168 @@
+module Steep
+  module Services
+    module HoverProvider
+      class Ruby
+        TypeContent = Struct.new(:node, :type, :location, keyword_init: true)
+        VariableContent = Struct.new(:node, :name, :type, :location, keyword_init: true)
+        MethodCallContent = Struct.new(:node, :method_call, :location, keyword_init: true)
+        DefinitionContent = Struct.new(:node, :method_name, :method_type, :definition, :location, keyword_init: true)
+        ConstantContent = Struct.new(:location, :full_name, :type, :decl, keyword_init: true) do
+          def comments
+            case
+            when class_or_module?
+              decl.decls.filter_map {|d| d.decl.comment }
+            when constant?
+              [decl.decl.comment]
+            else
+              []
+            end.compact
+          end
+
+          def constant?
+            decl.is_a?(::RBS::Environment::SingleEntry)
+          end
+
+          def class_or_module?
+            decl.is_a?(::RBS::Environment::MultiEntry)
+          end
+        end
+
+        attr_reader :service
+
+        def initialize(service:)
+          @service = service
+        end
+
+        def project
+          service.project
+        end
+
+        def method_definition_for(factory, type_name, singleton_method: nil, instance_method: nil)
+          case
+          when instance_method
+            factory.definition_builder.build_instance(type_name).methods[instance_method]
+          when singleton_method
+            methods = factory.definition_builder.build_singleton(type_name).methods
+
+            if singleton_method == :new
+              methods[:new] || methods[:initialize]
+            else
+              methods[singleton_method]
+            end
+          end
+        end
+
+        def typecheck(target, path:, content:, line:, column:)
+          subtyping = service.signature_services[target.name].current_subtyping or return
+          source = Source.parse(content, path: path, factory: subtyping.factory)
+          source = source.without_unrelated_defs(line: line, column: column)
+          Services::TypeCheckService.type_check(source: source, subtyping: subtyping)
+        rescue
+          nil
+        end
+
+        def method_name_from_method(context, builder:)
+          defined_in = context.method.defined_in
+          method_name = context.name
+
+          case
+          when defined_in.class?
+            case
+            when builder.build_instance(defined_in).methods.key?(method_name)
+              InstanceMethodName.new(type_name: defined_in, method_name: method_name)
+            when builder.build_singleton(defined_in).methods.key?(method_name)
+              SingletonMethodName.new(type_name: defined_in, method_name: method_name)
+            end
+          else
+            InstanceMethodName.new(type_name: defined_in, method_name: method_name)
+          end
+        end
+
+        def content_for(target:, path:, line:, column:)
+          file = service.source_files[path]
+          typing = typecheck(target, path: path, content: file.content, line: line, column: column) or return
+          node, *parents = typing.source.find_nodes(line: line, column: column)
+
+          if node
+            case node.type
+            when :lvar
+              var_name = node.children[0]
+              context = typing.context_at(line: line, column: column)
+              var_type = context.lvar_env[var_name] || AST::Types::Any.new(location: nil)
+
+              return VariableContent.new(node: node, name: var_name, type: var_type, location: node.location.name)
+
+            when :lvasgn
+              var_name, rhs = node.children
+              context = typing.context_at(line: line, column: column)
+              type = context.lvar_env[var_name] || typing.type_of(node: rhs)
+
+              return VariableContent.new(node: node, name: var_name, type: type, location: node.location.name)
+
+            when :send, :csend
+              result_node =
+                case parents[0]&.type
+                when :block, :numblock
+                  if node == parents[0].children[0]
+                    parents[0]
+                  else
+                    node
+                  end
+                else
+                  node
+                end
+
+              case call = typing.call_of(node: result_node)
+              when TypeInference::MethodCall::Typed, TypeInference::MethodCall::Error
+                unless call.method_decls.empty?
+                  return MethodCallContent.new(
+                    node: result_node,
+                    method_call: call,
+                    location: node.location.selector
+                  )
+                end
+              end
+
+            when :def, :defs
+              context = typing.context_at(line: line, column: column)
+              method_context = context.method_context
+
+              if method_context && method_context.method
+                return DefinitionContent.new(
+                  node: node,
+                  method_name: method_name_from_method(method_context, builder: context.factory.definition_builder),
+                  method_type: method_context.method_type,
+                  definition: method_context.method,
+                  location: node.loc.name
+                )
+              end
+
+            when :const, :casgn
+              context = typing.context_at(line: line, column: column)
+
+              type = typing.type_of(node: node)
+              const_name = typing.source_index.reference(constant_node: node)
+
+              if const_name
+                decl = context.env.class_decls[const_name] || context.env.constant_decls[const_name]
+
+                return ConstantContent.new(
+                  location: node.location.name,
+                  full_name: const_name,
+                  type: type,
+                  decl: decl
+                )
+              end
+            end
+
+            TypeContent.new(
+              node: node,
+              type: typing.type_of(node: node),
+              location: node.location.expression
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/services/hover_provider/singleton_methods.rb

@@ -0,0 +1,21 @@
+module Steep
+  module Services
+    module HoverProvider
+      module SingletonMethods
+        def content_for(service:, path:, line:, column:)
+          project = service.project
+          target_for_code, targets_for_sigs = project.targets_for_path(path)
+
+          case
+          when target_for_code
+            Ruby.new(service: service).content_for(target: target_for_code, path: path, line: line, column: column)
+          when target = targets_for_sigs.first
+            RBS.new(service: service).content_for(target: target, path: path, line: line, column: column)
+          end
+        end
+      end
+
+      extend SingletonMethods
+    end
+  end
+end

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.sort_by {|ty| (path = hole_path(ty)) ? -path.size : 1 }.each do |super_type|
+            relation.super_type.types.sort_by {|ty| (path = hole_path(ty)) ? -path.size : -Float::INFINITY }.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.sort_by {|ty| (path = hole_path(ty)) ? -path.size : 1 }.each do |sub_type|
+            relation.sub_type.types.sort_by {|ty| (path = hole_path(ty)) ? -path.size : -Float::INFINITY }.each do |sub_type|
               rel = Relation.new(sub_type: sub_type, super_type: relation.super_type)
               result.add(rel) do
                 check_type(rel)

data/lib/steep/type_construction.rb

@@ -2910,6 +2910,11 @@ module Steep
               call = call.with_return_type(typing.type_of(node: arguments.last))
             end
           end
+
+          if node.type == :csend || ((node.type == :block || node.type == :numblock) && node.children[0].type == :csend)
+            optional_type = AST::Types::Union.build(types: [call.return_type, AST::Builtin.nil_type])
+            call = call.with_return_type(optional_type)
+          end
         else
           error = Diagnostic::Ruby::UnresolvedOverloading.new(
             node: node,

data/lib/steep/type_inference/context.rb

@@ -171,6 +171,10 @@ module Steep
         )
       end
 
+      def factory
+        type_env.subtyping.factory
+      end
+
       def env
         type_env.subtyping.factory.env
       end

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.52.0"
+  VERSION = "0.52.1"
 end

data/lib/steep.rb

@@ -92,23 +92,26 @@ require "steep/index/rbs_index"
 require "steep/index/signature_symbol_provider"
 require "steep/index/source_index"
 
-require "steep/server/change_buffer"
-require "steep/server/base_worker"
-require "steep/server/worker_process"
-require "steep/server/interaction_worker"
-require "steep/server/type_check_worker"
-require "steep/server/master"
-
 require "steep/services/content_change"
 require "steep/services/path_assignment"
 require "steep/services/signature_service"
 require "steep/services/type_check_service"
-require "steep/services/hover_content"
+require "steep/services/hover_provider/singleton_methods"
+require "steep/services/hover_provider/ruby"
+require "steep/services/hover_provider/rbs"
 require "steep/services/completion_provider"
 require "steep/services/stats_calculator"
 require "steep/services/file_loader"
 require "steep/services/goto_service"
 
+require "steep/server/lsp_formatter"
+require "steep/server/change_buffer"
+require "steep/server/base_worker"
+require "steep/server/worker_process"
+require "steep/server/interaction_worker"
+require "steep/server/type_check_worker"
+require "steep/server/master"
+
 require "steep/project"
 require "steep/project/pattern"
 require "steep/project/options"

data/steep.gemspec

@@ -33,7 +33,7 @@ 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", "< 4.0"
-  spec.add_runtime_dependency "rbs", ">= 2.3.0"
+  spec.add_runtime_dependency "rbs", ">= 2.3.2"
   spec.add_runtime_dependency "parallel", ">= 1.0.0"
   spec.add_runtime_dependency "terminal-table", ">= 2", "< 4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 0.52.0
+  version: 0.52.1
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-04-05 00:00:00.000000000 Z
+date: 2022-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -98,14 +98,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.3.0
+        version: 2.3.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.3.0
+        version: 2.3.2
 - !ruby/object:Gem::Dependency
   name: parallel
   requirement: !ruby/object:Gem::Requirement
@@ -233,6 +233,7 @@ files:
 - lib/steep/server/base_worker.rb
 - lib/steep/server/change_buffer.rb
 - lib/steep/server/interaction_worker.rb
+- lib/steep/server/lsp_formatter.rb
 - lib/steep/server/master.rb
 - lib/steep/server/type_check_worker.rb
 - lib/steep/server/worker_process.rb
@@ -240,7 +241,9 @@ files:
 - lib/steep/services/content_change.rb
 - lib/steep/services/file_loader.rb
 - lib/steep/services/goto_service.rb
-- lib/steep/services/hover_content.rb
+- lib/steep/services/hover_provider/rbs.rb
+- lib/steep/services/hover_provider/ruby.rb
+- lib/steep/services/hover_provider/singleton_methods.rb
 - lib/steep/services/path_assignment.rb
 - lib/steep/services/signature_service.rb
 - lib/steep/services/stats_calculator.rb

data/lib/steep/services/hover_content.rb

@@ -1,254 +0,0 @@
-module Steep
-  module Services
-    class HoverContent
-      TypeContent = Struct.new(:node, :type, :location, keyword_init: true)
-      VariableContent = Struct.new(:node, :name, :type, :location, keyword_init: true)
-      MethodCallContent = Struct.new(:node, :method_name, :type, :definition, :location, keyword_init: true)
-      DefinitionContent = Struct.new(:node, :method_name, :method_type, :definition, :location, keyword_init: true) do
-        def comment_string
-          if comments = definition&.comments
-            comments.map {|c| c.string.chomp }.uniq.join("\n----\n")
-          end
-        end
-      end
-      ConstantContent = Struct.new(:location, :full_name, :type, :decl, keyword_init: true) do
-        def comment_string
-          if class_or_module?
-            comments = decl.decls.filter_map {|d| d.decl.comment&.string }
-            unless comments.empty?
-              return comments.join("\n----\n")
-            end
-          end
-
-          if constant?
-            if comment = decl.decl.comment
-              return comment.string
-            end
-          end
-
-          nil
-        end
-
-        def constant?
-          decl.is_a?(RBS::Environment::SingleEntry)
-        end
-
-        def class_or_module?
-          decl.is_a?(RBS::Environment::MultiEntry)
-        end
-      end
-
-      TypeAliasContent = Struct.new(:location, :decl, keyword_init: true)
-      ClassContent = Struct.new(:location, :decl, keyword_init: true)
-      InterfaceContent = Struct.new(:location, :decl, keyword_init: true)
-
-      InstanceMethodName = Struct.new(:class_name, :method_name)
-      SingletonMethodName = Struct.new(:class_name, :method_name)
-
-      attr_reader :service
-
-      def initialize(service:)
-        @service = service
-      end
-
-      def project
-        service.project
-      end
-
-      def method_definition_for(factory, type_name, singleton_method: nil, instance_method: nil)
-        case
-        when instance_method
-          factory.definition_builder.build_instance(type_name).methods[instance_method]
-        when singleton_method
-          methods = factory.definition_builder.build_singleton(type_name).methods
-
-          if singleton_method == :new
-            methods[:new] || methods[:initialize]
-          else
-            methods[singleton_method]
-          end
-        end
-      end
-
-      def typecheck(target, path:, content:, line:, column:)
-        subtyping = service.signature_services[target.name].current_subtyping or return
-        source = Source.parse(content, path: path, factory: subtyping.factory)
-        source = source.without_unrelated_defs(line: line, column: column)
-        Services::TypeCheckService.type_check(source: source, subtyping: subtyping)
-      rescue
-        nil
-      end
-
-      def content_for(path:, line:, column:)
-        target_for_code, targets_for_sigs = project.targets_for_path(path)
-
-        case
-        when target = target_for_code
-          Steep.logger.info "target #{target}"
-
-          hover_for_source(column, line, path, target)
-
-        when target = targets_for_sigs[0]
-          service = self.service.signature_services[target.name]
-
-          _buffer, decls = service.latest_env.buffers_decls.find do |buffer, _|
-            Pathname(buffer.name) == path
-          end
-
-          return if decls.nil?
-
-          locator = RBS::Locator.new(decls: decls)
-          hd, tail = locator.find2(line: line, column: column)
-
-          # Maybe hover on comment
-          return if tail.nil?
-
-          case type = tail[0]
-          when RBS::Types::Alias
-            alias_decl = service.latest_env.alias_decls[type.name]&.decl or raise
-
-            location = tail[0].location
-            TypeAliasContent.new(
-              location: location,
-              decl: alias_decl
-            )
-          when RBS::Types::ClassInstance, RBS::Types::ClassSingleton
-            if hd == :name
-              env = service.latest_env
-              class_decl = env.class_decls[type.name]&.decls[0]&.decl or raise
-              location = tail[0].location[:name]
-              ClassContent.new(
-                location: location,
-                decl: class_decl
-              )
-            end
-          when RBS::Types::Interface
-            env = service.latest_env
-            interface_decl = env.interface_decls[type.name]&.decl or raise
-            location = type.location[:name]
-
-            InterfaceContent.new(
-              location: location,
-              decl: interface_decl
-            )
-          end
-        end
-      end
-
-      def hover_for_source(column, line, path, target)
-        file = service.source_files[path]
-        typing = typecheck(target, path: path, content: file.content, line: line, column: column) or return
-        node, *parents = typing.source.find_nodes(line: line, column: column)
-
-        if node
-          case node.type
-          when :lvar
-            var_name = node.children[0]
-            context = typing.context_at(line: line, column: column)
-            var_type = context.lvar_env[var_name] || AST::Types::Any.new(location: nil)
-
-            VariableContent.new(node: node, name: var_name, type: var_type, location: node.location.name)
-          when :lvasgn
-            var_name, rhs = node.children
-            context = typing.context_at(line: line, column: column)
-            type = context.lvar_env[var_name] || typing.type_of(node: rhs)
-
-            VariableContent.new(node: node, name: var_name, type: type, location: node.location.name)
-          when :send
-            receiver, method_name, *_ = node.children
-
-            result_node = case parents[0]&.type
-                          when :block, :numblock
-                            parents[0]
-                          else
-                            node
-                          end
-
-            context = typing.context_at(line: line, column: column)
-
-            receiver_type = if receiver
-                              typing.type_of(node: receiver)
-                            else
-                              context.self_type
-                            end
-
-            factory = context.type_env.subtyping.factory
-            method_name, definition = case receiver_type
-                                      when AST::Types::Name::Instance
-                                        method_definition = method_definition_for(factory, receiver_type.name, instance_method: method_name)
-                                        if method_definition&.defined_in
-                                          owner_name = method_definition.defined_in
-                                          [
-                                            InstanceMethodName.new(owner_name, method_name),
-                                            method_definition
-                                          ]
-                                        end
-                                      when AST::Types::Name::Singleton
-                                        method_definition = method_definition_for(factory, receiver_type.name, singleton_method: method_name)
-                                        if method_definition&.defined_in
-                                          owner_name = method_definition.defined_in
-                                          [
-                                            SingletonMethodName.new(owner_name, method_name),
-                                            method_definition
-                                          ]
-                                        end
-                                      else
-                                        nil
-                                      end
-
-            MethodCallContent.new(
-              node: node,
-              method_name: method_name,
-              type: typing.type_of(node: result_node),
-              definition: definition,
-              location: result_node.location.expression
-            )
-          when :def, :defs
-            context = typing.context_at(line: line, column: column)
-            method_context = context.method_context
-
-            if method_context && method_context.method
-              DefinitionContent.new(
-                node: node,
-                method_name: method_context.name,
-                method_type: method_context.method_type,
-                definition: method_context.method,
-                location: node.loc.expression
-              )
-            end
-          when :const, :casgn
-            context = typing.context_at(line: line, column: column)
-
-            type = typing.type_of(node: node)
-            const_name = typing.source_index.reference(constant_node: node)
-
-            if const_name
-              decl = context.env.class_decls[const_name] || context.env.constant_decls[const_name]
-
-              ConstantContent.new(
-                location: node.location.name,
-                full_name: const_name,
-                type: type,
-                decl: decl
-              )
-            else
-              TypeContent.new(
-                node: node,
-                type: type,
-                location: node.location.expression
-              )
-            end
-          else
-            type = typing.type_of(node: node)
-
-            TypeContent.new(
-              node: node,
-              type: type,
-              location: node.location.expression
-            )
-          end
-        end
-      end
-    end
-  end
-end