steep 0.30.0 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5293cbc87834cee36e50cb66bab84e466a5182c1e868732b7bd3e685b2bd954
-  data.tar.gz: 7794e42573b5ac04c74780824213cfbe1ca255f1feaa4465a1066377d2647e0b
+  metadata.gz: e315b0a9541b0289ae3c9dd3acb19c2112e990a321176f94ed44f25d4190acb4
+  data.tar.gz: 9ce6e2024e81e5a2452fc5d7ca381decd1d91ed917d385dc280133652af51e06
 SHA512:
-  metadata.gz: e723bf77a7452e0696c38d6d1797e71f246fb97d1b1f18082ba21b8eadb8174d6bcc4deda872898b5f39d162b91173c413cacfa28175018517170f8f2568bd70
-  data.tar.gz: 38dbe78df43706fe33d5350ad04524c25606955bcba5397ad18690717a60c59d361485ad2d5d3077787336d23902bd91ba9fa5b31e1933a93d1fe32747837688
+  metadata.gz: bd8db01573d1a2e31b362fb893bfad1325969b8343415d1bfd82428a76f0a6c8f8fe2875f7e474ab94244476e9901b1dda186f57cb90a49602638453826534a8
+  data.tar.gz: f1f30e2afc48265917468a4c5dd040fff3e226f92cb17441c3f3fcbba7f95aaa1002172ece399410d567358d9caf7bd80c1f1c27b9083c81a39e1abe61b74a68

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## master
 
+## 0.31.0 (2020-10-04)
+
+* Fix type checking performance ([#230](https://github.com/soutaro/steep/pull/230))
+* Improve LSP completion/hover performance ([#232](https://github.com/soutaro/steep/pull/232))
+* Fix instance variable completion ([#234](https://github.com/soutaro/steep/pull/234))
+* Relax version requirements on Listen to allow installing on Ruby 3 ([#235](https://github.com/soutaro/steep/pull/235))
+
 ## 0.30.0 (2020-10-03)
 
 * Let top-level defs be methods of Object ([#227](https://github.com/soutaro/steep/pull/227))

data/bin/steep-prof

@@ -9,8 +9,7 @@ def exit(*)
 
 end
 
-
 STDERR.puts "Running profiler: mode=#{mode}, out=#{out}"
-StackProf.run(mode: mode, out: out) do
+StackProf.run(mode: mode, out: out, raw: true) do
   load File.join(__dir__, "../exe/steep")
 end

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

@@ -7,11 +7,14 @@ module Steep
         attr_reader :type_name_cache
         attr_reader :type_cache
 
+        attr_reader :type_interface_cache
+
         def initialize(builder:)
           @definition_builder = builder
 
           @type_name_cache = {}
           @type_cache = {}
+          @type_interface_cache = {}
         end
 
         def type_name_resolver
@@ -390,15 +393,23 @@ module Steep
 
         def interface(type, private:, self_type: type)
           Steep.logger.debug { "Factory#interface: #{type}, private=#{private}, self_type=#{self_type}" }
-          type = expand_alias(type)
+
+          cache_key = [type, self_type, private]
+          if type_interface_cache.key?(cache_key)
+            return type_interface_cache[cache_key]
+          end
 
           case type
+          when Name::Alias
+            interface(expand_alias(type), private: private, self_type: self_type)
+
           when Self
             if self_type != type
               interface self_type, private: private, self_type: Self.new
             else
               raise "Unexpected `self` type interface"
             end
+            
           when Name::Instance
             Interface::Interface.new(type: self_type, private: private).tap do |interface|
               definition = definition_builder.build_instance(type.name)
@@ -689,6 +700,8 @@ module Steep
 
           else
             raise "Unexpected type for interface: #{type}"
+          end.tap do |interface|
+            type_interface_cache[cache_key] = interface
           end
         end
 

data/lib/steep/project/completion_provider.rb

@@ -29,11 +29,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 +55,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 +68,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 +221,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
 

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

data/lib/steep/server/interaction_worker.rb

@@ -52,21 +52,23 @@ module Steep
 
       def response_to_hover(path:, line:, column:)
         Steep.logger.tagged "#response_to_hover" do
-          Steep.logger.debug { "path=#{path}, line=#{line}, column=#{column}" }
-
-          hover = Project::HoverContent.new(project: project)
-          content = hover.content_for(path: path, line: line+1, column: column+1)
-          if content
-            range = content.location.yield_self do |location|
-              start_position = { line: location.line - 1, character: location.column }
-              end_position = { line: location.last_line - 1, character: location.last_column }
-              { start: start_position, end: end_position }
-            end
+          Steep.measure "Generating response" do
+            Steep.logger.info { "path=#{path}, line=#{line}, column=#{column}" }
+
+            hover = Project::HoverContent.new(project: project)
+            content = hover.content_for(path: path, line: line+1, column: column+1)
+            if content
+              range = content.location.yield_self do |location|
+                start_position = { line: location.line - 1, character: location.column }
+                end_position = { line: location.last_line - 1, character: location.last_column }
+                { start: start_position, end: end_position }
+              end
 
-            LSP::Interface::Hover.new(
-              contents: { kind: "markdown", value: format_hover(content) },
-              range: range
-            )
+              LSP::Interface::Hover.new(
+                contents: { kind: "markdown", value: format_hover(content) },
+                range: range
+              )
+            end
           end
         rescue Typing::UnknownNodeError => exn
           Steep.log_error exn, message: "Failed to compute hover: #{exn.inspect}"
@@ -126,33 +128,35 @@ HOVER
 
       def response_to_completion(path:, line:, column:, trigger:)
         Steep.logger.tagged("#response_to_completion") do
-          Steep.logger.info "path: #{path}, line: #{line}, column: #{column}, trigger: #{trigger}"
-
-          target = project.targets.find {|target| target.source_file?(path) } or return
-          target.type_check(target_sources: [], validate_signatures: false)
-
-          case (status = target&.status)
-          when Project::Target::TypeCheckStatus
-            subtyping = status.subtyping
-            source = target.source_files[path]
+          Steep.measure "Generating response" do
+            Steep.logger.info "path: #{path}, line: #{line}, column: #{column}, trigger: #{trigger}"
+
+            target = project.target_for_source_path(path) or return
+            target.type_check(target_sources: [], validate_signatures: false)
+
+            case (status = target&.status)
+            when Project::Target::TypeCheckStatus
+              subtyping = status.subtyping
+              source = target.source_files[path]
+
+              provider = Project::CompletionProvider.new(source_text: source.content, path: path, subtyping: subtyping)
+              items = begin
+                        provider.run(line: line, column: column)
+                      rescue Parser::SyntaxError
+                        []
+                      end
+
+              completion_items = items.map do |item|
+                format_completion_item(item)
+              end
 
-            provider = Project::CompletionProvider.new(source_text: source.content, path: path, subtyping: subtyping)
-            items = begin
-                      provider.run(line: line, column: column)
-                    rescue Parser::SyntaxError
-                      []
-                    end
+              Steep.logger.debug "items = #{completion_items.inspect}"
 
-            completion_items = items.map do |item|
-              format_completion_item(item)
+              LSP::Interface::CompletionList.new(
+                is_incomplete: false,
+                items: completion_items
+              )
             end
-
-            Steep.logger.debug "items = #{completion_items.inspect}"
-
-            LSP::Interface::CompletionList.new(
-              is_incomplete: false,
-              items: completion_items
-            )
           end
         end
       end

data/lib/steep/source.rb

@@ -276,6 +276,18 @@ module Steep
       end
     end
 
+    def self.map_child_nodes(node)
+      children = node.children.map do |child|
+        if child.is_a?(::AST::Node)
+          yield child
+        else
+          child
+        end
+      end
+
+      node.updated(nil, children)
+    end
+
     def annotations(block:, factory:, current_module:)
       AST::Annotation::Collection.new(
         annotations: mapping[block.__id__] || [],
@@ -316,5 +328,50 @@ module Steep
         end
       end
     end
+
+    def self.delete_defs(node, allow_list)
+      case node.type
+      when :def
+        if allow_list.include?(node)
+          node
+        else
+          node.updated(:nil, [])
+        end
+      when :defs
+        if allow_list.include?(node)
+          node
+        else
+          delete_defs(node.children[0], allow_list)
+        end
+      else
+        map_child_nodes(node) do |child|
+          delete_defs(child, allow_list)
+        end
+      end
+    end
+
+    def without_unrelated_defs(line:, column:)
+      nodes = find_nodes(line: line, column: column) || []
+      defs = Set[].compare_by_identity.merge(nodes.select {|node| node.type == :def || node.type == :defs })
+
+      node_ = Source.delete_defs(node, defs)
+
+      Source.new(path: path, node: node_, mapping: mapping)
+    end
+
+    def compact_siblings(node)
+      case node
+      when :def
+        node.updated(:nil, [])
+      when :defs
+        node.children[0]
+      when :class
+        node.updated(:class, [node.children[0], node.children[1], nil])
+      when :module
+        node.updated(:module, [node.children[0], nil])
+      else
+        node
+      end
+    end
   end
 end

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.30.0"
+  VERSION = "0.31.0"
 end

data/steep.gemspec

@@ -32,7 +32,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "ast_utils", "~> 0.3.0"
   spec.add_runtime_dependency "activesupport", ">= 5.1"
   spec.add_runtime_dependency "rainbow", ">= 2.2.2", "< 4.0"
-  spec.add_runtime_dependency "listen", "~> 3.1"
+  spec.add_runtime_dependency "listen", "~> 3.0"
   spec.add_runtime_dependency "language_server-protocol", "~> 3.15.0.1"
   spec.add_runtime_dependency "rbs", "~> 0.12.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.31.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-10-02 00:00:00.000000000 Z
+date: 2020-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -78,14 +78,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
   requirement: !ruby/object:Gem::Requirement