steep 0.28.0 → 0.32.0

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

@@ -0,0 +1,63 @@
+module Steep
+  module AST
+    module Types
+      module Logic
+        class Base
+          attr_reader :location
+
+          def subst(s)
+            self
+          end
+
+          def free_variables
+            @fvs ||= Set[]
+          end
+
+          def hash
+            self.class.hash
+          end
+
+          def ==(other)
+            other.class ==self.class
+          end
+
+          alias eql? ==
+
+          def to_s
+            "<% #{self.class} %>"
+          end
+        end
+
+        class Not < Base
+          def initialize(location: nil)
+            @location = location
+          end
+        end
+
+        class ReceiverIsNil < Base
+          def initialize(location: nil)
+            @location = location
+          end
+        end
+
+        class ReceiverIsNotNil < Base
+          def initialize(location: nil)
+            @location = location
+          end
+        end
+
+        class ReceiverIsArg < Base
+          def initialize(location: nil)
+            @location = location
+          end
+        end
+
+        class ArgIsReceiver < Base
+          def initialize(location: nil)
+            @location = location
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/interface/method_type.rb

@@ -775,13 +775,15 @@ module Steep
       attr_reader :block
       attr_reader :return_type
       attr_reader :location
+      attr_reader :method_def
 
-      def initialize(type_params:, params:, block:, return_type:, location:)
+      def initialize(type_params:, params:, block:, return_type:, location:, method_def:)
         @type_params = type_params
         @params = params
         @block = block
         @return_type = return_type
         @location = location
+        @method_def = method_def
       end
 
       def ==(other)
@@ -790,6 +792,7 @@ module Steep
           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)
       end
 
@@ -821,6 +824,7 @@ module Steep
           params: params.subst(s_),
           block: block&.subst(s_),
           return_type: return_type.subst(s_),
+          method_def: method_def,
           location: location
         )
       end
@@ -843,14 +847,16 @@ module Steep
                        params: params.subst(s),
                        block: block&.subst(s),
                        return_type: return_type.subst(s),
-                       location: location)
+                       location: location,
+                       method_def: method_def)
       end
 
-      def with(type_params: self.type_params, params: self.params, block: self.block, return_type: self.return_type, location: self.location)
+      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)
         self.class.new(type_params: type_params,
                        params: params,
                        block: block,
                        return_type: return_type,
+                       method_def: method_def,
                        location: location)
       end
 
@@ -867,7 +873,8 @@ module Steep
                        params: params.map_type(&block),
                        block: self.block&.yield_self {|blk| blk.map_type(&block) },
                        return_type: yield(return_type),
-                       location: location)
+                       location: location,
+                       method_def: method_def)
       end
 
       # Returns a new method type which can be used for the method implementation type of both `self` and `other`.
@@ -895,6 +902,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
         )
       end
@@ -950,6 +958,7 @@ module Steep
           block: block,
           return_type: return_type,
           type_params: type_params,
+          method_def: nil,
           location: nil
         )
       end
@@ -997,6 +1006,7 @@ module Steep
           block: block,
           return_type: return_type,
           type_params: type_params,
+          method_def: nil,
           location: nil
         )
       end

data/lib/steep/module_helper.rb

@@ -0,0 +1,25 @@
+module Steep
+  module ModuleHelper
+    def module_name_from_node(node)
+      case node.type
+      when :const, :casgn
+        namespace = namespace_from_node(node.children[0]) or return
+        name = node.children[1]
+        RBS::TypeName.new(name: name, namespace: namespace)
+      end
+    end
+
+    def namespace_from_node(node)
+      case node&.type
+      when nil
+        RBS::Namespace.empty
+      when :cbase
+        RBS::Namespace.root
+      when :const
+        namespace_from_node(node.children[0])&.yield_self do |parent|
+          parent.append(node.children[1])
+        end
+      end
+    end
+  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

@@ -10,13 +10,9 @@ 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, :definition, :def_type, :inherited_method, keyword_init: true) do
-        def method_type
-          def_type.type
-        end
-
+      MethodNameItem = Struct.new(:identifier, :range, :method_def, :method_type, :inherited_method, keyword_init: true) do
         def comment
-          def_type.comment
+          method_def&.comment
         end
       end
 
@@ -33,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
@@ -57,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
 
@@ -70,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
             []
@@ -90,7 +88,9 @@ module Steep
       end
 
       def at_end?(pos, of:)
-        of.last_line == pos.line && of.last_column == pos.column
+        if of
+          of.last_line == pos.line && of.last_column == pos.column
+        end
       end
 
       def range_for(position, prefix: "")
@@ -194,21 +194,25 @@ module Steep
         return [] unless node
 
         if at_end?(shift_pos, of: node.loc)
-          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)
-          items
+          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)
+            items
+          rescue Typing::UnknownNodeError
+            []
+          end
         else
           []
         end
@@ -217,50 +221,40 @@ 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
 
       def method_items_for_receiver_type(type, include_private:, prefix:, position:, items:)
         range = range_for(position, prefix: prefix)
-        definition = case type
-                     when AST::Types::Name::Instance
-                       type_name = subtyping.factory.type_name_1(type.name)
-                       subtyping.factory.definition_builder.build_instance(type_name)
-                     when AST::Types::Name::Singleton
-                       type_name = subtyping.factory.type_name_1(type.name)
-                       subtyping.factory.definition_builder.build_singleton(type_name)
-                     when AST::Types::Name::Interface
-                       type_name = subtyping.factory.type_name_1(type.name)
-                       subtyping.factory.definition_builder.build_interface(type_name)
-                     end
-
-        if definition
-          definition.methods.each do |name, method|
-            next if disallowed_method?(name)
-
-            if include_private || method.public?
-              if name.to_s.start_with?(prefix)
-                if word_name?(name.to_s)
-                  method.defs.each do |def_type|
-                    items << MethodNameItem.new(identifier: name,
-                                                range: range,
-                                                definition: method,
-                                                def_type: def_type,
-                                                inherited_method: inherited_method?(method, definition))
-                  end
-                end
+        interface = subtyping.factory.interface(type, self_type: type, private: include_private)
+
+        interface.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,
+                  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)
+                )
               end
             end
           end
         end
+      rescue
+        # nop
       end
 
       def word_name?(name)
@@ -304,8 +298,13 @@ module Steep
         index
       end
 
-      def inherited_method?(method, definition)
-        method.implemented_in != definition.type_name
+      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)

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

@@ -21,9 +21,7 @@ module Steep
         @project = project
       end
 
-      def method_definition_for(factory, module_name, singleton_method: nil, instance_method: nil)
-        type_name = factory.type_name_1(module_name)
-
+      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]
@@ -38,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)
 
-          case (status = source_file.status)
-          when SourceFile::TypeCheckStatus
-            node, *parents = status.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)
 
-            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: 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)
 
-                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
 
-                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
 
-                result_node = if parents[0]&.type == :block
-                                parents[0]
+              context = typing.context_at(line: line, column: column)
+
+              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 = factory.type_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 = factory.type_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