steep 1.4.0.dev.3 → 1.4.0.dev.4

data/lib/steep/services/completion_provider.rb

@@ -26,43 +26,78 @@ module Steep
         def comments
           case entry = env.constant_entry(full_name)
           when RBS::Environment::ConstantEntry
-            [entry.decl.comment].compact
+            [entry.decl.comment]
           when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
-            entry.decls.filter_map {|d| d.decl.comment }
+            entry.decls.map {|d| d.decl.comment }
           when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
-            [entry.decl.comment].compact
+            [entry.decl.comment]
+          else
+            raise
+          end
+        end
+
+        def decl
+          case entry = env.constant_entry(full_name)
+          when RBS::Environment::ConstantEntry
+            entry.decl
+          when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
+            entry.primary.decl
+          when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
+            entry.decl
           else
             raise
           end
         end
       end
-      MethodNameItem = _ = Struct.new(:identifier, :range, :receiver_type, :method_type, :method_decls, keyword_init: true) do
-        # @implements MethodNameItem
+
+      SimpleMethodNameItem = _ = Struct.new(:identifier, :range, :receiver_type, :method_types, :method_member, :method_name, keyword_init: true) do
+        # @implements SimpleMethodNameItem
 
         def comment
-          case method_decls.size
-          when 0
-            nil
-          when 1
-            method = method_decls.to_a.first or raise
-            method.method_def&.comment
-          else
-            nil
+          method_member.comment
+        end
+      end
+
+      ComplexMethodNameItem = _ = Struct.new(:identifier, :range, :receiver_type, :method_types, :method_decls, keyword_init: true) do
+        # @implements ComplexMethodNameItem
+
+        def method_names
+          method_definitions.keys
+        end
+
+        def method_definitions
+          method_decls.each.with_object({}) do |decl, hash| #$ Hash[method_name, RBS::Definition::Method::method_member]
+            method_name = defining_method_name(
+              decl.method_def.defined_in,
+              decl.method_name.method_name,
+              decl.method_def.member
+            )
+            hash[method_name] = decl.method_def.member
           end
         end
 
-        def inherited?
-          case receiver_type = receiver_type()
-          when AST::Types::Name::Instance, AST::Types::Name::Singleton, AST::Types::Name::Interface
-            method_decls.any? do |decl|
-              decl.method_name.type_name != receiver_type.name
+        def defining_method_name(type_name, name, member)
+          case member
+          when RBS::AST::Members::MethodDefinition
+            if member.instance?
+              InstanceMethodName.new(type_name: type_name, method_name: name)
+            else
+              SingletonMethodName.new(type_name: type_name, method_name: name)
+            end
+          when RBS::AST::Members::Attribute
+            if member.kind == :instance
+              InstanceMethodName.new(type_name: type_name, method_name: name)
+            else
+              SingletonMethodName.new(type_name: type_name, method_name: name)
             end
-          else
-            false
           end
         end
       end
 
+      GeneratedMethodNameItem = _ = Struct.new(:identifier, :range, :receiver_type, :method_types, keyword_init: true) do
+        # @implements GeneratedMethodNameItem
+      end
+
       attr_reader :source_text
       attr_reader :path
       attr_reader :subtyping
@@ -168,51 +203,40 @@ module Steep
 
         return [] unless node
 
-        items = []
+        items = [] #: Array[item]
 
         context = typing.context_at(line: position.line, column: position.column)
 
         case
-        when node.type == :send && node.children[0] == nil && at_end?(position, of: node.loc.selector)
+        when node.type == :send && node.children[0] == nil && at_end?(position, of: (_ = node.loc).selector)
           # foo ←
           prefix = node.children[1].to_s
 
-          method_items_for_receiver_type(context.self_type,
-                                         include_private: true,
-                                         prefix: prefix,
-                                         position: position,
-                                         items: items)
+          method_items_for_receiver_type(context.self_type, include_private: true, prefix: prefix, position: position, items: items)
           local_variable_items_for_context(context, position: position, prefix: prefix, items: items)
 
         when node.type == :lvar && at_end?(position, of: node.loc)
           # foo ← (lvar)
           local_variable_items_for_context(context, position: position, prefix: node.children[0].to_s, items: items)
 
-        when node.type == :send && node.children[0] && at_end?(position, of: node.loc.selector)
+        when node.type == :send && node.children[0] && at_end?(position, of: (_ = node.loc).selector)
           # foo.ba ←
-          receiver_type = case (type = typing.type_of(node: node.children[0]))
-                          when AST::Types::Self
-                            context.self_type
-                          else
-                            type
-                          end
+          receiver_type =
+            case (type = typing.type_of(node: node.children[0]))
+            when AST::Types::Self
+              context.self_type
+            else
+              type
+            end
           prefix = node.children[1].to_s
 
-          method_items_for_receiver_type(receiver_type,
-                                         include_private: false,
-                                         prefix: prefix,
-                                         position: position,
-                                         items: items)
+          method_items_for_receiver_type(receiver_type, include_private: false, prefix: prefix, position: position, items: items)
 
         when node.type == :const && node.children[0] == nil && at_end?(position, of: node.loc)
           # Foo ← (const)
           prefix = node.children[1].to_s
 
-          method_items_for_receiver_type(context.self_type,
-                                         include_private: false,
-                                         prefix: prefix,
-                                         position: position,
-                                         items: items)
+          method_items_for_receiver_type(context.self_type, include_private: false, prefix: prefix, position: position, items: items)
           constant_items_for_context(context, prefix: prefix, position: position, items: items)
 
         when node.type == :const && node.children[0] && at_end?(position, of: node.loc)
@@ -223,30 +247,23 @@ module Steep
           if parent_type
             prefix = node.children[1].to_s
 
-            method_items_for_receiver_type(parent_type,
-                                           include_private: false,
-                                           prefix: prefix,
-                                           position: position,
-                                           items: items)
+            method_items_for_receiver_type(parent_type, include_private: false, prefix: prefix, position: position, items: items)
             constant_items_for_context(context, parent: parent_node, prefix: prefix, position: position, items: items)
           end
 
-        when node.type == :send && at_end?(position, of: node.loc.dot) && node.loc.dot.source == "."
+        when node.type == :send && at_end?(position, of: (_ = node.loc).dot) && (_ = node.loc).dot.source == "."
           # foo.← ba
-          receiver_type = case (type = typing.type_of(node: node.children[0]))
-                          when AST::Types::Self
-                            context.self_type
-                          else
-                            type
-                          end
-
-          method_items_for_receiver_type(receiver_type,
-                                         include_private: false,
-                                         prefix: "",
-                                         position: position,
-                                         items: items)
-
-        when node.type == :send && at_end?(position, of: node.loc.dot) && node.loc.dot.source == "::"
+          receiver_type =
+            case (type = typing.type_of(node: node.children[0]))
+            when AST::Types::Self
+              context.self_type
+            else
+              type
+            end
+
+          method_items_for_receiver_type(receiver_type, include_private: false, prefix: "", position: position, items: items)
+
+        when node.type == :send && at_end?(position, of: (_ = node.loc).dot) && (_ = node.loc).dot.source == "::"
           # foo::← ba
           items.push(*items_for_colon2(position: position))
 
@@ -255,11 +272,7 @@ module Steep
           instance_variable_items_for_context(context, position: position, prefix: node.children[0].to_s, items: items)
 
         else
-          method_items_for_receiver_type(context.self_type,
-                                         include_private: true,
-                                         prefix: "",
-                                         position: position,
-                                         items: items)
+          method_items_for_receiver_type(context.self_type, include_private: true, prefix: "", position: position, items: items)
           local_variable_items_for_context(context, position: position, prefix: "", items: items)
           instance_variable_items_for_context(context, position: position, prefix: "", items: items)
           constant_items_for_context(context, position: position, prefix: "", items: items)
@@ -279,19 +292,16 @@ module Steep
         if at_end?(shift_pos, of: node.loc)
           begin
             context = typing.context_at(line: position.line, column: position.column)
-            receiver_type = case (type = typing.type_of(node: node))
-                            when AST::Types::Self
-                              context.self_type
-                            else
-                              type
-                            end
-
-            items = []
-            method_items_for_receiver_type(receiver_type,
-                                           include_private: false,
-                                           prefix: "",
-                                           position: position,
-                                           items: items)
+            receiver_type =
+              case (type = typing.type_of(node: node))
+              when AST::Types::Self
+                context.self_type
+              else
+                type
+              end
+
+            items = [] #: Array[item]
+            method_items_for_receiver_type(receiver_type, include_private: false, prefix: "", position: position, items: items)
             items
           rescue Typing::UnknownNodeError
             []
@@ -307,7 +317,7 @@ module Steep
         node, *_ = source.find_nodes(line: shift_pos.line, column: shift_pos.column)
         node ||= source.node
 
-        items = []
+        items = [] #: Array[item]
         case node&.type
         when :const
           # Constant:: ←
@@ -335,7 +345,7 @@ module Steep
         return [] unless node
 
         context = typing.context_at(line: position.line, column: position.column)
-        items = []
+        items = [] #: Array[item]
         instance_variable_items_for_context(context, prefix: "@", position: position, items: items)
         items
       end
@@ -354,31 +364,60 @@ module Steep
             variable_bounds: context.variable_context.upper_bounds
           )
         )
-        # factory.shape(type, self_type: type, private: include_private)
 
-        shape.methods.each do |name, method_entry|
-          next if disallowed_method?(name)
+        if shape
+          shape.methods.each do |name, method_entry|
+            next if disallowed_method?(name)
 
-          if name.to_s.start_with?(prefix)
-            if word_name?(name.to_s)
-              method_entry.method_types.each do |method_type|
-                items << MethodNameItem.new(
-                  identifier: name,
-                  range: range,
-                  receiver_type: type,
-                  method_type: subtyping.factory.method_type_1(method_type),
-                  method_decls: method_type.method_decls
-                )
+            if name.to_s.start_with?(prefix)
+              if word_name?(name.to_s)
+                case type
+                when AST::Types::Name::Instance, AST::Types::Name::Interface, AST::Types::Name::Singleton
+                  # Simple method type
+                  all_decls = Set.new(method_entry.method_types.flat_map {|method_type| method_type.method_decls.to_a }).sort_by {|decl| decl.method_name.to_s }
+                  all_members = Set.new(all_decls.flat_map {|decl| decl.method_def.member })
+                  all_members.each do |member|
+                    associated_decl = all_decls.find {|decl| decl.method_def.member == member } or next
+                    method_types = method_entry.method_types.select {|method_type| method_type.method_decls.any? {|decl| decl.method_def.member == member }}
+                    items << SimpleMethodNameItem.new(
+                      identifier: name,
+                      range: range,
+                      receiver_type: type,
+                      method_name: associated_decl.method_name,
+                      method_types: method_types.map {|type| subtyping.factory.method_type_1(type) },
+                      method_member: member
+                    )
+                  end
+                else
+                  generated_method_types, defined_method_types = method_entry.method_types.partition {|method_type| method_type.method_decls.empty? }
+
+                  unless defined_method_types.empty?
+                    items << ComplexMethodNameItem.new(
+                      identifier: name,
+                      range: range,
+                      receiver_type: type,
+                      method_types: defined_method_types.map {|type| subtyping.factory.method_type_1(type) },
+                      method_decls: defined_method_types.flat_map {|type| type.method_decls.to_a }.sort_by {|decl| decl.method_name.to_s }
+                    )
+                  end
+
+                  unless generated_method_types.empty?
+                    items << GeneratedMethodNameItem.new(
+                      identifier: name,
+                      range: range,
+                      receiver_type: type,
+                      method_types: generated_method_types.map {|type| subtyping.factory.method_type_1(type) }
+                    )
+                  end
+                end
               end
             end
           end
         end
-      rescue RuntimeError => _exn
-        # nop
       end
 
       def word_name?(name)
-        name =~ /\w/
+        name =~ /\w/ ? true : false
       end
 
       def local_variable_items_for_context(context, position:, prefix:, items:)
@@ -420,9 +459,7 @@ module Steep
         range = range_for(position, prefix: prefix)
         context.type_env.instance_variable_types.each do |name, type|
           if name.to_s.start_with?(prefix)
-            items << InstanceVariableItem.new(identifier: name,
-                                              range: range,
-                                              type: type)
+            items << InstanceVariableItem.new(identifier: name, range: range, type: type)
           end
         end
       end

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

@@ -29,54 +29,59 @@ module Steep
 
           case head
           when ::RBS::Types::Alias
-            alias_decl = service.latest_env.type_alias_decls[head.name]&.decl or raise
+            content_for_type_name(head.name, env: env, location: head.location || raise)
 
-            TypeAliasContent.new(
-              location: head.location || raise,
-              decl: alias_decl
-            )
           when ::RBS::Types::ClassInstance, ::RBS::Types::ClassSingleton
             if loc_key == :name
               location = head.location&.[](:name) or raise
-
-              class_entry = service.latest_env.module_class_entry(head.name) or raise
-              case class_entry
-              when ::RBS::Environment::ClassEntry, ::RBS::Environment::ModuleEntry
-                class_decl = class_entry.primary.decl
-              when ::RBS::Environment::ClassAliasEntry, ::RBS::Environment::ModuleAliasEntry
-                class_decl = class_entry.decl
-              end
-
-              ClassContent.new(
-                location: location,
-                decl: class_decl
-              )
+              content_for_type_name(head.name, env: env, location: location)
             end
+
           when ::RBS::Types::Interface
-            env = service.latest_env
-            interface_decl = env.interface_decls[head.name]&.decl or raise
             location = head.location&.[](:name) or raise
+            content_for_type_name(head.name, env: env, location: location)
 
-            InterfaceContent.new(
-              location: location,
-              decl: interface_decl
-            )
           when ::RBS::AST::Declarations::ClassAlias, ::RBS::AST::Declarations::ModuleAlias
             if loc_key == :old_name
               location = head.location&.[](:old_name) or raise
+              content_for_type_name(head.old_name, env: env, location: location)
+            end
 
-              class_entry = service.latest_env.module_class_entry(head.old_name) or raise
-              case class_entry
-              when ::RBS::Environment::ClassEntry, ::RBS::Environment::ModuleEntry
-                class_decl = class_entry.primary.decl
-              when ::RBS::Environment::ClassAliasEntry, ::RBS::Environment::ModuleAliasEntry
-                class_decl = class_entry.decl
-              end
+          when ::RBS::AST::Directives::Use::SingleClause
+            if loc_key == :type_name
+              location = head.location&.[](:type_name) or raise
+              content_for_type_name(head.type_name.absolute!, env: env, location: location)
+            end
 
-              ClassContent.new(location: location, decl: class_decl)
+          when ::RBS::AST::Directives::Use::WildcardClause
+            if loc_key == :namespace
+              location = head.location&.[](:namespace) or raise
+              content_for_type_name(head.namespace.to_type_name.absolute!, env: env, location: location)
             end
           end
         end
+
+        def content_for_type_name(type_name, env:, location:)
+          case
+          when type_name.alias?
+            alias_decl = env.type_alias_decls[type_name]&.decl or return
+            TypeAliasContent.new(location: location, decl: alias_decl)
+          when type_name.interface?
+            interface_decl = env.interface_decls[type_name]&.decl or return
+            InterfaceContent.new(location: location, decl: interface_decl)
+          when type_name.class?
+            class_entry = env.module_class_entry(type_name) or return
+
+            case class_entry
+            when ::RBS::Environment::ClassEntry, ::RBS::Environment::ModuleEntry
+              class_decl = class_entry.primary.decl
+            when ::RBS::Environment::ClassAliasEntry, ::RBS::Environment::ModuleAliasEntry
+              class_decl = class_entry.decl
+            end
+
+            ClassContent.new(location: location, decl: class_decl)
+          end
+        end
       end
     end
   end

data/lib/steep/services/signature_help_provider.rb

@@ -0,0 +1,108 @@
+module Steep
+  module Services
+    class SignatureHelpProvider
+      MethodCall = TypeInference::MethodCall
+
+      Item = _ = Struct.new(:method_type, :comment)
+
+      attr_reader :source, :path, :subtyping, :typing, :buffer
+
+      def env
+        subtyping.factory.env
+      end
+
+      def initialize(source:, subtyping:)
+        @source = source
+        @subtyping = subtyping
+
+        text =
+          if source.node
+            source.node.loc.expression.source
+          end
+        @buffer = RBS::Buffer.new(name: source.path, content: text || "")
+      end
+
+      def run(line:, column:)
+        nodes = source.find_nodes(line: line, column: column)
+
+        return unless nodes
+
+        typing = type_check!(line: line, column: column)
+
+        while true
+          node = nodes.shift()
+          parent = nodes.first
+
+          node or return
+
+          if node.type == :send
+            pos = buffer.loc_to_pos([line, column])
+            begin_loc = (_ = node.loc).begin #: Parser::Source::Range?
+            end_loc = (_ = node.loc).end #: Parser::Source::Range?
+
+            if begin_loc && end_loc
+              if begin_loc.end_pos <= pos && pos <= end_loc.begin_pos
+                # Given position is between open/close parens of args of send node
+
+                if parent && (parent.type == :block || parent.type == :numblock)
+                  send_node = parent.children[0]
+                else
+                  send_node = node
+                end
+
+                return signature_help_for(send_node, typing)
+              end
+            end
+          end
+        end
+      end
+
+      def type_check!(line:, column:)
+        source = self.source.without_unrelated_defs(line: line, column: column)
+        resolver = RBS::Resolver::ConstantResolver.new(builder: subtyping.factory.definition_builder)
+        TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver)
+      end
+
+      def signature_help_for(node, typing)
+        call = typing.call_of(node: node)
+        context = typing.context_at(line: node.loc.expression.line, column: node.loc.expression.column)
+
+        items = [] #: Array[Item]
+        index = nil #: Integer?
+
+        case call
+        when MethodCall::Typed, MethodCall::Error
+          type = call.receiver_type
+          if type.is_a?(AST::Types::Self)
+            type = context.self_type
+          end
+
+          shape = subtyping.builder.shape(
+            type,
+            public_only: !node.children[0].nil?,
+            config: Interface::Builder::Config.new(self_type: type, class_type: nil, instance_type: nil, variable_bounds: {})
+          )
+          if shape
+            if method = shape.methods[call.method_name]
+              method.method_types.each.with_index do |method_type, i|
+                defn = method_type.method_decls.to_a[0]&.method_def
+
+                items << Item.new(subtyping.factory.method_type_1(method_type), defn&.comment)
+
+                if call.is_a?(MethodCall::Typed)
+                  if method_type.method_decls.intersect?(call.method_decls)
+                    index = i
+                  end
+                end
+              end
+            end
+          end
+        when MethodCall::Untyped, MethodCall::NoMethodError
+          return
+        end
+
+        [items, index]
+      end
+    end
+  end
+end

data/lib/steep/services/type_name_completion.rb

@@ -90,9 +90,17 @@ module Steep
 
       def each_type_name(&block)
         if block
+          env = self.env
+
           map.instance_eval do
             @map.each_key do |name|
-              yield RBS::TypeName.new(name: name, namespace: RBS::Namespace.empty)
+              relative_name = RBS::TypeName.new(name: name, namespace: RBS::Namespace.empty)
+              if absolute_name = resolve?(relative_name)
+                if env.type_name?(absolute_name)
+                  # Yields only if the relative type name resolves to existing absolute type name
+                  yield relative_name
+                end
+              end
             end
           end
           env.class_decls.each_key(&block)