steep 0.30.0 → 0.34.0

data/lib/steep/errors.rb

@@ -101,20 +101,6 @@ module Steep
       end
     end
 
-    class IncompatibleBlockParameters < Base
-      attr_reader :node
-      attr_reader :method_type
-
-      def initialize(node:, method_type:)
-        super(node: node)
-        @method_type = method_type
-      end
-
-      def to_s
-        "#{location_to_str}: IncompatibleBlockParameters: method_type=#{method_type}"
-      end
-    end
-
     class BlockParameterTypeMismatch < Base
       attr_reader :expected
       attr_reader :actual
@@ -186,7 +172,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: RequiredBlockMissing: method_type=#{method_type.location&.source}"
+        "#{location_to_str}: RequiredBlockMissing: method_type=#{method_type.to_s}"
       end
     end
 
@@ -557,5 +543,23 @@ module Steep
         "#{location_to_str}: UnsupportedSyntax: #{msg}"
       end
     end
+
+    class UnexpectedError < Base
+      attr_reader :message
+      attr_reader :error
+
+      def initialize(node:, error:)
+        super(node: node)
+        @error = error
+        @message = error.message
+      end
+
+      def to_s
+        <<-MESSAGE
+#{location_to_str}: UnexpectedError: #{error.class}
+>> #{message}
+        MESSAGE
+      end
+    end
   end
 end

data/lib/steep/interface/method_type.rb

@@ -774,16 +774,14 @@ module Steep
       attr_reader :params
       attr_reader :block
       attr_reader :return_type
-      attr_reader :location
-      attr_reader :method_def
+      attr_reader :method_decls
 
-      def initialize(type_params:, params:, block:, return_type:, location:, method_def:)
+      def initialize(type_params:, params:, block:, return_type:, method_decls:)
         @type_params = type_params
         @params = params
         @block = block
         @return_type = return_type
-        @location = location
-        @method_def = method_def
+        @method_decls = method_decls
       end
 
       def ==(other)
@@ -791,9 +789,7 @@ module Steep
           other.type_params == type_params &&
           other.params == params &&
           other.block == block &&
-          other.return_type == return_type &&
-          (!other.method_def || !method_def || other.method_def == method_def) &&
-          (!other.location || !location || other.location == location)
+          other.return_type == return_type
       end
 
       alias eql? ==
@@ -824,8 +820,7 @@ module Steep
           params: params.subst(s_),
           block: block&.subst(s_),
           return_type: return_type.subst(s_),
-          method_def: method_def,
-          location: location
+          method_decls: method_decls
         )
       end
 
@@ -847,17 +842,15 @@ module Steep
                        params: params.subst(s),
                        block: block&.subst(s),
                        return_type: return_type.subst(s),
-                       location: location,
-                       method_def: method_def)
+                       method_decls: method_decls)
       end
 
-      def with(type_params: self.type_params, params: self.params, block: self.block, return_type: self.return_type, location: self.location,  method_def: self.method_def)
+      def with(type_params: self.type_params, params: self.params, block: self.block, return_type: self.return_type, method_decls: self.method_decls)
         self.class.new(type_params: type_params,
                        params: params,
                        block: block,
                        return_type: return_type,
-                       method_def: method_def,
-                       location: location)
+                       method_decls: method_decls)
       end
 
       def to_s
@@ -873,8 +866,7 @@ module Steep
                        params: params.map_type(&block),
                        block: self.block&.yield_self {|blk| blk.map_type(&block) },
                        return_type: yield(return_type),
-                       location: location,
-                       method_def: method_def)
+                       method_decls: method_decls)
       end
 
       # Returns a new method type which can be used for the method implementation type of both `self` and `other`.
@@ -902,8 +894,7 @@ module Steep
           return_type: AST::Types::Union.build(
             types: [return_type.subst(s1),other.return_type.subst(s2)]
           ),
-          method_def: method_def,
-          location: nil
+          method_decls: method_decls + other.method_decls
         )
       end
 
@@ -958,8 +949,7 @@ module Steep
           block: block,
           return_type: return_type,
           type_params: type_params,
-          method_def: nil,
-          location: nil
+          method_decls: method_decls + other.method_decls
         )
       end
 
@@ -1006,8 +996,7 @@ module Steep
           block: block,
           return_type: return_type,
           type_params: type_params,
-          method_def: nil,
-          location: nil
+          method_decls: method_decls + other.method_decls
         )
       end
     end

data/lib/steep/method_name.rb

@@ -0,0 +1,28 @@
+module Steep
+  InstanceMethodName = Struct.new(:type_name, :method_name, keyword_init: true) do
+    def to_s
+      "#{type_name}##{method_name}"
+    end
+  end
+
+  SingletonMethodName = Struct.new(:type_name, :method_name, keyword_init: true) do
+    def to_s
+      "#{type_name}.#{method_name}"
+    end
+  end
+
+  module ::Kernel
+    def MethodName(string)
+      case string
+      when /#/
+        type_name, method_name = string.split(/#/, 2)
+        InstanceMethodName.new(type_name: TypeName(type_name), method_name: method_name.to_sym)
+      when /\./
+        type_name, method_name = string.split(/\./, 2)
+        SingletonMethodName.new(type_name: TypeName(type_name), method_name: method_name.to_sym)
+      else
+        raise "Unexpected method name: #{string}"
+      end
+    end
+  end
+end

data/lib/steep/project/completion_provider.rb

@@ -10,9 +10,27 @@ module Steep
 
       InstanceVariableItem = Struct.new(:identifier, :range, :type, keyword_init: true)
       LocalVariableItem = Struct.new(:identifier, :range, :type, keyword_init: true)
-      MethodNameItem = Struct.new(:identifier, :range, :method_def, :method_type, :inherited_method, keyword_init: true) do
+      MethodNameItem = Struct.new(:identifier, :range, :receiver_type, :method_type, :method_decls, keyword_init: true) do
         def comment
-          method_def&.comment
+          case method_decls.size
+          when 0
+            nil
+          when 1
+            method_decls.to_a.first.method_def&.comment
+          else
+            nil
+          end
+        end
+
+        def inherited?
+          case 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
+            end
+          else
+            false
+          end
         end
       end
 
@@ -29,11 +47,13 @@ module Steep
         @subtyping = subtyping
       end
 
-      def type_check!(text)
+      def type_check!(text, line:, column:)
         @modified_text = text
 
         Steep.measure "parsing" do
-          @source = SourceFile.parse(text, path: path, factory: subtyping.factory)
+          @source = SourceFile
+                      .parse(text, path: path, factory: subtyping.factory)
+                      .without_unrelated_defs(line: line, column: column)
         end
 
         Steep.measure "typechecking" do
@@ -53,7 +73,7 @@ module Steep
         begin
           Steep.logger.tagged "completion_provider#run(line: #{line}, column: #{column})" do
             Steep.measure "type_check!" do
-              type_check!(source_text)
+              type_check!(source_text, line: line, column: column)
             end
           end
 
@@ -66,11 +86,11 @@ module Steep
           case possible_trigger
           when "."
             source_text[index-1] = " "
-            type_check!(source_text)
+            type_check!(source_text, line: line, column: column)
             items_for_dot(position: position)
           when "@"
             source_text[index-1] = " "
-            type_check!(source_text)
+            type_check!(source_text, line: line, column: column)
             items_for_atmark(position: position)
           else
             []
@@ -219,14 +239,14 @@ module Steep
       def items_for_atmark(position:)
         # @ ←
         shift_pos = position-1
-        node, *parents = source.find_nodes(line: shift_pos.line, column: shift_pos.column)
+        node, *_ = source.find_nodes(line: shift_pos.line, column: shift_pos.column)
         node ||= source.node
 
         return [] unless node
 
         context = typing.context_at(line: position.line, column: position.column)
         items = []
-        instance_variable_items_for_context(context, prefix: "", position: position, items: items)
+        instance_variable_items_for_context(context, prefix: "@", position: position, items: items)
         items
       end
 
@@ -243,15 +263,15 @@ module Steep
                 items << MethodNameItem.new(
                   identifier: name,
                   range: range,
-                  method_def: method_type.method_def,
-                  method_type: method_type.method_def&.type || subtyping.factory.method_type_1(method_type, self_type: type),
-                  inherited_method: inherited_method?(method_type.method_def, type)
+                  receiver_type: type,
+                  method_type: subtyping.factory.method_type_1(method_type, self_type: type),
+                  method_decls: method_type.method_decls
                 )
               end
             end
           end
         end
-      rescue
+      rescue RuntimeError => exn
         # nop
       end
 
@@ -296,15 +316,6 @@ module Steep
         index
       end
 
-      def inherited_method?(method_def, type)
-        case type
-        when AST::Types::Name::Instance, AST::Types::Name::Singleton, AST::Types::Name::Interface
-          method_def.implemented_in != type.name
-        else
-          false
-        end
-      end
-
       def disallowed_method?(name)
         # initialize isn't invoked by developers when creating
         # instances of new classes, so don't show it as

data/lib/steep/project/hover_content.rb

@@ -36,102 +36,113 @@ module Steep
         end
       end
 
+      def typecheck(target, path:, line:, column:)
+        target.type_check(target_sources: [], validate_signatures: false)
+
+        case (status = target.status)
+        when Project::Target::TypeCheckStatus
+          subtyping = status.subtyping
+          source = SourceFile
+                     .parse(target.source_files[path].content, path: path, factory: subtyping.factory)
+                     .without_unrelated_defs(line: line, column: column)
+          SourceFile.type_check(source, subtyping: subtyping)
+        end
+      rescue
+        nil
+      end
+
       def content_for(path:, line:, column:)
-        target = project.targets.find {|target| target.source_file?(path) }
+        target = project.target_for_source_path(path)
 
         if target
-          source_file = target.source_files[path]
-          target.type_check(target_sources: [source_file], validate_signatures: false)
+          typing = typecheck(target, path: path, 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.name] || AST::Types::Any.new(location: nil)
 
-          case (status = source_file.status)
-          when SourceFile::TypeCheckStatus
-            node, *parents = status.source.find_nodes(line: line, column: column)
+              VariableContent.new(node: node, name: var_name.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.name] || typing.type_of(node: rhs)
 
-            if node
-              case node.type
-              when :lvar
-                var_name = node.children[0]
-                context = status.typing.context_at(line: line, column: column)
-                var_type = context.lvar_env[var_name.name] || AST::Types::Any.new(location: nil)
+              VariableContent.new(node: node, name: var_name.name, type: type, location: node.location.name)
+            when :send
+              receiver, method_name, *_ = node.children
 
-                VariableContent.new(node: node, name: var_name.name, type: var_type, location: node.location.name)
-              when :lvasgn
-                var_name, rhs = node.children
-                context = status.typing.context_at(line: line, column: column)
-                type = context.lvar_env[var_name.name] || status.typing.type_of(node: rhs)
 
-                VariableContent.new(node: node, name: var_name.name, type: type, location: node.location.name)
-              when :send
-                receiver, method_name, *_ = node.children
+              result_node = if parents[0]&.type == :block
+                              parents[0]
+                            else
+                              node
+                            end
 
+              context = typing.context_at(line: line, column: column)
 
-                result_node = if parents[0]&.type == :block
-                                parents[0]
+              receiver_type = if receiver
+                                typing.type_of(node: receiver)
                               else
-                                node
+                                context.self_type
                               end
 
-                context = status.typing.context_at(line: line, column: column)
-
-                receiver_type = if receiver
-                                  status.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
+              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
-
-                MethodCallContent.new(
-                  node: node,
-                  method_name: method_name,
-                  type: status.typing.type_of(node: result_node),
-                  definition: definition,
-                  location: result_node.location.expression
-                )
-              when :def, :defs
-                context = status.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
-              else
-                type = status.typing.type_of(node: node)
-
-                TypeContent.new(
+                                        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,
-                  type: type,
-                  location: node.location.expression
+                  method_name: method_context.name,
+                  method_type: method_context.method_type,
+                  definition: method_context.method,
+                  location: node.loc.expression
                 )
               end
+            else
+              type = typing.type_of(node: node)
+
+              TypeContent.new(
+                node: node,
+                type: type,
+                location: node.location.expression
+              )
             end
           end
         end