steep 0.51.0 → 0.52.2

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/shims/filter_map.rb

@@ -0,0 +1,30 @@
+# Steep runs on Ruby 2.6 and it needs a shim of `filter_map`
+
+module Shims
+  module EnumerableFilterMap
+    def filter_map(&block)
+      if block
+        result = []
+
+        each do |element|
+          if value = yield(element)
+            result << value
+          end
+        end
+
+        result
+      else
+        enum_for :filter_map
+      end
+    end
+  end
+
+  unless Enumerable.method_defined?(:filter_map)
+    Enumerable.include EnumerableFilterMap
+
+    module ::Enumerable
+      alias filter_map filter_map
+    end
+  end
+end
+

data/lib/steep/source.rb

@@ -301,13 +301,42 @@ module Steep
       end
     end
 
-    def find_nodes(line:, column:, node: self.node, position: nil, parents: [])
-      return [] unless node
+    def each_heredoc_node(node = self.node, parents = [], &block)
+      if block
+        case node.type
+        when :dstr, :str
+          if node.location.is_a?(Parser::Source::Map::Heredoc)
+            yield [node, *parents]
+          end
+        end
 
-      position ||= (line-1).times.sum do |i|
-        node.location.expression.source_buffer.source_line(i+1).size + 1
-      end + column
+        parents.unshift(node)
+        Source.each_child_node(node) do |child|
+          each_heredoc_node(child, parents, &block)
+        end
+        parents.shift()
+      else
+        enum_for :each_heredoc_node, node
+      end
+    end
 
+    def find_heredoc_nodes(line, column, position)
+      each_heredoc_node() do |nodes|
+        node = nodes[0]
+
+        range = node.location.heredoc_body&.yield_self do |r|
+          r.begin_pos..r.end_pos
+        end
+
+        if range && (range === position)
+          return nodes
+        end
+      end
+
+      nil
+    end
+
+    def find_nodes_loc(node, position, parents)
       range = node.location.expression&.yield_self do |r|
         r.begin_pos..r.end_pos
       end
@@ -317,7 +346,7 @@ module Steep
           parents.unshift node
 
           Source.each_child_node(node) do |child|
-            ns = find_nodes(line: line, column: column, node: child, position: position, parents: parents) and return ns
+            ns = find_nodes_loc(child, position, parents) and return ns
           end
 
           parents
@@ -325,6 +354,24 @@ module Steep
       end
     end
 
+    def find_nodes(line:, column:)
+      return [] unless node
+
+      position = (line-1).times.sum do |i|
+        node.location.expression.source_buffer.source_line(i+1).size + 1
+      end + column
+
+      if nodes = find_heredoc_nodes(line, column, position)
+        Source.each_child_node(nodes[0]) do |child|
+          find_nodes_loc(child, position, nodes) and break
+        end
+
+        nodes
+      else
+        find_nodes_loc(node, position, [])
+      end
+    end
+
     def self.delete_defs(node, allow_list)
       case node.type
       when :def

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

@@ -1498,13 +1498,18 @@ module Steep
             end
 
             if super_node
-              _, constr, super_name = constr.synthesize_constant(super_node, super_node.children[0], super_node.children[1]) do
-                typing.add_error(
-                  Diagnostic::Ruby::UnknownConstant.new(node: super_node, name: super_node.children[1]).class!
-                )
-              end
-              if super_name
-                typing.source_index.add_reference(constant: super_name, ref: super_node)
+              if super_node.type == :const
+                _, constr, super_name = constr.synthesize_constant(super_node, super_node.children[0], super_node.children[1]) do
+                  typing.add_error(
+                    Diagnostic::Ruby::UnknownConstant.new(node: super_node, name: super_node.children[1]).class!
+                  )
+                end
+
+                if super_name
+                  typing.source_index.add_reference(constant: super_name, ref: super_node)
+                end
+              else
+                _, constr = synthesize(super_node, hint: nil, condition: false)
               end
             end
 
@@ -2731,6 +2736,14 @@ module Steep
 
               return [type, constr, name]
             end
+          when AST::Types::Any
+            # Couldn't detect the type of the parent constant
+            # Skip reporting error for this node.
+            if node
+              _, constr = add_typing(node, type: parent_type)
+            end
+
+            return [parent_type, constr, nil]
           end
         end
 
@@ -2744,6 +2757,10 @@ module Steep
           end
         end
 
+        if node
+          _, constr = add_typing(node, type: AST::Builtin.any_type)
+        end
+
         [AST::Builtin.any_type, constr, nil]
       end
     end
@@ -2898,6 +2915,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,
@@ -3964,6 +3986,11 @@ module Steep
     end
 
     def try_convert(type, method)
+      case type
+      when AST::Types::Any, AST::Types::Bot, AST::Types::Top, AST::Types::Var
+        return
+      end
+
       interface = checker.factory.interface(type, private: false)
       if entry = interface.methods[method]
         method_type = entry.method_types.find do |method_type|

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.51.0"
+  VERSION = "0.52.2"
 end

data/lib/steep.rb

@@ -21,6 +21,8 @@ require "terminal-table"
 
 require "rbs"
 
+require "steep/shims/filter_map"
+
 require "steep/equatable"
 require "steep/method_name"
 require "steep/ast/types/helper"
@@ -92,23 +94,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/smoke/diagnostics/test_expectations.yml

@@ -557,16 +557,6 @@
     severity: ERROR
     message: 'Cannot find the declaration of constant: `FOO`'
     code: Ruby::UnknownConstant
-  - range:
-      start:
-        line: 4
-        character: 7
-      end:
-        line: 4
-        character: 10
-    severity: ERROR
-    message: 'Cannot find the declaration of constant: `BAR`'
-    code: Ruby::UnknownConstant
   - range:
       start:
         line: 6

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.51.0
+  version: 0.52.2
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-04-01 00:00:00.000000000 Z
+date: 2022-05-02 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,11 +241,14 @@ 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
 - lib/steep/services/type_check_service.rb
+- lib/steep/shims/filter_map.rb
 - lib/steep/signature/validator.rb
 - lib/steep/source.rb
 - lib/steep/subtyping/cache.rb