steep 0.29.0 → 0.33.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d09c66d40509db4956625f6be82477c4cda1b375d4cc37ebc2b4fdfdfdd971f
-  data.tar.gz: bfe074e9fc6e833faa4442f718e2bade7e54a5b6921fd8cf63465972ec39ced5
+  metadata.gz: e93086efe3704ac8b59a1450fda301b7ab91f409c13c53a679a2ed3b3419ca84
+  data.tar.gz: b00e2030a9ea2171b6f967c78f469204c903cb937d421e5dcab896021fce2919
 SHA512:
-  metadata.gz: 05d54b1565ccf9189d335163d952d075bd6f7b3a08c26362efb815c3d19cfd2ffa2eb13e124a5dc7a4a5f1343a6fbbe5694ed3d6000a4fe37f3ace4cb2d7c1d5
-  data.tar.gz: 2661d5a8a5273e5c4341b27fd78a5f57c296c31663f16d46bf8de39ea1af40b827bfdf48f9266e071a37b1fe395a58ec716149d88656cf983587ecbe89fa24e6
+  metadata.gz: 06023d31b509f58efdea8c8f0e13c49b38f3a4936debbe3a0d88bfd84b356e7a761506a8f105c035bd454a4b2f39ae6af13d16b84d29e6d0050d9d58d7062e82
+  data.tar.gz: '0601459d31ad8ca758c95c29215eb237b5bc50490b5133e574057ec1836396d9189c3dd22628244c1d8d432e0f945a746c280ae96ca20b768c063fbae0c696af'

data/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## master
 
+## 0.33.0 (2020-10-13)
+
+* Make `!` typing flow sensitive ([#240](https://github.com/soutaro/steep/pull/240))
+
+## 0.32.0 (2020-10-09)
+
+* Let type-case support interface types ([#237](https://github.com/soutaro/steep/pull/237))
+
+## 0.31.1 (2020-10-07)
+
+* Fix `if-then-else` parsing ([#236](https://github.com/soutaro/steep/pull/236))
+
+## 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))
+* Fix error caused by attribute definitions ([#228](https://github.com/soutaro/steep/pull/228))
+* LSP worker improvements ([#222](https://github.com/soutaro/steep/pull/222), [#223](https://github.com/soutaro/steep/pull/223), [#226](https://github.com/soutaro/steep/pull/226), [#229](https://github.com/soutaro/steep/pull/229))
+
 ## 0.29.0 (2020-09-28)
 
 * Implement reasoning on `is_a?`, `nil?`, and `===` methods. ([#218](https://github.com/soutaro/steep/pull/218))

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.rb

@@ -16,7 +16,6 @@ require 'uri'
 
 require "rbs"
 
-require "steep/ast/location"
 require "steep/ast/types/helper"
 require "steep/ast/types/any"
 require "steep/ast/types/instance"
@@ -39,7 +38,6 @@ require "steep/ast/types/logic"
 require "steep/ast/type_params"
 require "steep/ast/annotation"
 require "steep/ast/annotation/collection"
-require "steep/ast/buffer"
 require "steep/ast/builtin"
 require "steep/ast/types/factory"
 
@@ -83,7 +81,8 @@ require "steep/server/interaction_worker"
 require "steep/server/master"
 
 require "steep/project"
-require "steep/project/file"
+require "steep/project/signature_file"
+require "steep/project/source_file"
 require "steep/project/options"
 require "steep/project/target"
 require "steep/project/dsl"

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
@@ -339,46 +342,48 @@ module Steep
           end
         end
 
+        NilClassName = TypeName("::NilClass")
+
         def setup_primitives(method_name, method_type)
           if method_def = method_type.method_def
             defined_in = method_def.defined_in
             member = method_def.member
 
-            case
-            when defined_in == RBS::BuiltinNames::Object.name && member.instance?
+            if member.is_a?(RBS::AST::Members::MethodDefinition)
               case method_name
               when :is_a?, :kind_of?, :instance_of?
-                return method_type.with(
-                  return_type: AST::Types::Logic::ReceiverIsArg.new(location: method_type.return_type.location)
-                )
-              when :nil?
-                return method_type.with(
-                  return_type: AST::Types::Logic::ReceiverIsNil.new(location: method_type.return_type.location)
-                )
-              end
+                if defined_in == RBS::BuiltinNames::Object.name && member.instance?
+                  return method_type.with(
+                    return_type: AST::Types::Logic::ReceiverIsArg.new(location: method_type.return_type.location)
+                  )
+                end
 
-            when defined_in == AST::Builtin::NilClass.module_name && member.instance?
-              case method_name
               when :nil?
-                return method_type.with(
-                  return_type: AST::Types::Logic::ReceiverIsNil.new(location: method_type.return_type.location)
-                )
-              end
+                case defined_in
+                when RBS::BuiltinNames::Object.name,
+                  NilClassName
+                  return method_type.with(
+                    return_type: AST::Types::Logic::ReceiverIsNil.new(location: method_type.return_type.location)
+                  )
+                end
 
-            when defined_in == RBS::BuiltinNames::BasicObject.name && member.instance?
-              case method_name
               when :!
-                return method_type.with(
-                  return_type: AST::Types::Logic::Not.new(location: method_type.return_type.location)
-                )
-              end
+                case defined_in
+                when RBS::BuiltinNames::BasicObject.name,
+                  RBS::BuiltinNames::TrueClass.name,
+                  RBS::BuiltinNames::FalseClass.name
+                  return method_type.with(
+                    return_type: AST::Types::Logic::Not.new(location: method_type.return_type.location)
+                  )
+                end
 
-            when defined_in == RBS::BuiltinNames::Module.name && member.instance?
-              case method_name
               when :===
-                return method_type.with(
-                  return_type: AST::Types::Logic::ArgIsReceiver.new(location: method_type.return_type.location)
-                )
+                case defined_in
+                when RBS::BuiltinNames::Module.name
+                  return method_type.with(
+                    return_type: AST::Types::Logic::ArgIsReceiver.new(location: method_type.return_type.location)
+                  )
+                end
               end
             end
           end
@@ -388,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)
@@ -687,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.rb

@@ -24,6 +24,31 @@ module Steep
       (base_dir + path).cleanpath
     end
 
+    def target_for_source_path(path)
+      targets.find do |target|
+        target.possible_source_file?(path)
+      end
+    end
+
+    def targets_for_path(path)
+      if target = target_for_source_path(path)
+        [target, []]
+      else
+        [
+          nil,
+          targets.select do |target|
+            target.possible_signature_file?(path)
+          end
+        ]
+      end
+    end
+
+    def all_source_files
+      targets.each.with_object(Set[]) do |target, paths|
+        paths.merge(target.source_files.keys)
+      end
+    end
+
     def type_of_node(path:, line:, column:)
       source_file = targets.map {|target| target.source_files[path] }.compact[0]
 

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/file_loader.rb

@@ -28,15 +28,20 @@ module Steep
       end
 
       def load_sources(command_line_patterns)
+        loaded_paths = Set[]
+
         project.targets.each do |target|
           Steep.logger.tagged "target=#{target.name}" do
             target_patterns = command_line_patterns.empty? ? target.source_patterns : command_line_patterns
 
-            each_path_in_patterns target_patterns, ".rb" do |path|
+            each_path_in_patterns(target_patterns, ".rb") do |path|
               if target.possible_source_file?(path)
-                unless target.source_file?(path)
+                if loaded_paths.include?(path)
+                  Steep.logger.warn { "Skipping #{target} while loading #{path}... (Already loaded to another target.)" }
+                else
                   Steep.logger.info { "Adding source file: #{path}" }
                   target.add_source path, project.absolute_path(path).read
+                  loaded_paths << path
                 end
               end
             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