steep 0.43.0 → 0.45.0

data/lib/steep/services/file_loader.rb

@@ -8,29 +8,36 @@ module Steep
       end
 
       def each_path_in_patterns(pattern, commandline_patterns = [])
-        pats = commandline_patterns.empty? ? pattern.patterns : commandline_patterns
-
-        pats.each do |path|
-          absolute_path = base_dir + path
-
-          if absolute_path.file?
-            yield absolute_path.relative_path_from(base_dir)
-          else
-            files = if absolute_path.directory?
-                      Pathname.glob("#{absolute_path}/**/*#{pattern.ext}")
-                    else
-                      Pathname.glob(absolute_path)
-                    end
-
-            files.sort.each do |source_path|
-              if source_path.file?
-                relative_path = source_path.relative_path_from(base_dir)
-                unless pattern.ignore?(relative_path)
-                  yield relative_path
+        if block_given?
+          pats = commandline_patterns.empty? ? pattern.patterns : commandline_patterns
+
+          pats.each do |path|
+            absolute_path = base_dir + path
+
+            if absolute_path.file?
+              if pattern =~ path
+                yield absolute_path.relative_path_from(base_dir)
+              end
+            else
+              files = if absolute_path.directory?
+                        Pathname.glob("#{absolute_path}/**/*#{pattern.ext}")
+                      else
+                        Pathname.glob(absolute_path)
+                      end
+
+              files.sort.each do |source_path|
+                if source_path.file?
+                  relative_path = source_path.relative_path_from(base_dir)
+                  unless pattern.ignore?(relative_path)
+                    yield relative_path
+                  end
                 end
               end
             end
+
           end
+        else
+          enum_for :each_path_in_patterns, pattern, commandline_patterns
         end
       end
 

data/lib/steep/services/goto_service.rb

@@ -0,0 +1,322 @@
+module Steep
+  module Services
+    class GotoService
+      include ModuleHelper
+
+      module SourceHelper
+        def from_ruby?
+          from == :ruby
+        end
+
+        def from_rbs?
+          from == :rbs
+        end
+      end
+
+      ConstantQuery = Struct.new(:name, :from, keyword_init: true) do
+        include SourceHelper
+      end
+      MethodQuery = Struct.new(:name, :from, keyword_init: true) do
+        include SourceHelper
+      end
+      TypeNameQuery = Struct.new(:name, keyword_init: true)
+
+      attr_reader :type_check
+
+      def initialize(type_check:)
+        @type_check = type_check
+      end
+
+      def project
+        type_check.project
+      end
+
+      def implementation(path:, line:, column:)
+        locations = []
+
+        relative_path = project.relative_path(path)
+
+        queries = query_at(path: path, line: line, column: column)
+        queries.uniq!
+
+        queries.each do |query|
+          case query
+          when ConstantQuery
+            constant_definition_in_ruby(query.name, locations: locations)
+          when MethodQuery
+            method_locations(query.name, locations: locations, in_ruby: true, in_rbs: false)
+          when TypeNameQuery
+            type_name_locations(query.name, locations: locations)
+          end
+        end
+
+        locations.uniq
+      end
+
+      def definition(path:, line:, column:)
+        locations = []
+
+        relative_path = project.relative_path(path)
+
+        queries = query_at(path: path, line: line, column: column)
+        queries.uniq!
+
+        queries.each do |query|
+          case query
+          when ConstantQuery
+            constant_definition_in_rbs(query.name, locations: locations) if query.from_ruby?
+            constant_definition_in_ruby(query.name, locations: locations) if query.from_rbs?
+          when MethodQuery
+            method_locations(
+              query.name,
+              locations: locations,
+              in_ruby: query.from_rbs?,
+              in_rbs: query.from_ruby?
+            )
+          when TypeNameQuery
+            type_name_locations(query.name, locations: locations)
+          end
+        end
+
+        locations.uniq
+      end
+
+      def test_ast_location(loc, line:, column:)
+        return false if line < loc.line
+        return false if line == loc.line && column < loc.column
+        return false if loc.last_line < line
+        return false if line == loc.last_line && loc.last_column < column
+        true
+      end
+
+      def query_at(path:, line:, column:)
+        queries = []
+
+        relative_path = project.relative_path(path)
+
+        case
+        when target = type_check.source_file?(relative_path)
+          source = type_check.source_files[relative_path]
+          typing, signature = type_check_path(target: target, path: relative_path, content: source.content, line: line, column: column)
+          if typing
+            node, *parents = typing.source.find_nodes(line: line, column: column)
+            if node
+              case node.type
+              when :const, :casgn
+                if test_ast_location(node.location.name, line: line, column: column)
+                  if module_context = typing.context_at(line: line, column: column).module_context
+                    const_env = module_context.const_env
+                    const = const_env.lookup_constant(module_name_from_node(node))
+                    queries << ConstantQuery.new(name: const.name, from: :ruby)
+                  end
+                end
+              when :def, :defs
+                if test_ast_location(node.location.name, line: line, column: column)
+                  if method_context = typing.context_at(line: line, column: column).method_context
+                    type_name = method_context.method.defined_in
+                    name =
+                      if method_context.method.defs.any? {|defn| defn.member.singleton? }
+                        SingletonMethodName.new(type_name: type_name, method_name: method_context.name)
+                      else
+                        InstanceMethodName.new(type_name: type_name, method_name: method_context.name)
+                      end
+                    queries << MethodQuery.new(name: name, from: :ruby)
+                  end
+                end
+              when :send
+                if test_ast_location(node.location.selector, line: line, column: column)
+                  node = parents[0] if parents[0]&.type == :block
+                  case call = typing.call_of(node: node)
+                  when TypeInference::MethodCall::Typed, TypeInference::MethodCall::Error
+                    call.method_decls.each do |decl|
+                      queries << MethodQuery.new(name: decl.method_name, from: :ruby)
+                    end
+                  when TypeInference::MethodCall::Untyped
+                    # nop
+                  when TypeInference::MethodCall::NoMethodError
+                    # nop
+                  end
+                end
+              end
+            end
+          end
+        when target_names = type_check.signature_file?(path)
+          target_names.each do |target_name|
+            signature_service = type_check.signature_services[target_name]
+            decls = signature_service.latest_env.declarations.select do |decl|
+              buffer_path = Pathname(decl.location.buffer.name)
+              buffer_path == relative_path || buffer_path == path
+            end
+
+            locator = RBS::Locator.new(decls: decls)
+            last, nodes = locator.find2(line: line, column: column)
+            case nodes[0]
+            when RBS::AST::Declarations::Class, RBS::AST::Declarations::Module
+              if last == :name
+                queries << ConstantQuery.new(name: nodes[0].name, from: :rbs)
+              end
+            when RBS::AST::Declarations::Constant
+              if last == :name
+                queries << ConstantQuery.new(name: nodes[0].name, from: :rbs)
+              end
+            when RBS::AST::Members::MethodDefinition
+              if last == :name
+                type_name = nodes[1].name
+                method_name = nodes[0].name
+                if nodes[0].instance?
+                  queries << MethodQuery.new(
+                    name: InstanceMethodName.new(type_name: type_name, method_name: method_name),
+                    from: :rbs
+                  )
+                end
+                if nodes[0].singleton?
+                  queries << MethodQuery.new(
+                    name: SingletonMethodName.new(type_name: type_name, method_name: method_name),
+                    from: :rbs
+                  )
+                end
+              end
+            when RBS::AST::Members::Include, RBS::AST::Members::Extend, RBS::AST::Members::Prepend
+              if last == :name
+                queries << TypeNameQuery.new(name: nodes[0].name)
+              end
+            when RBS::Types::ClassInstance, RBS::Types::ClassSingleton, RBS::Types::Interface, RBS::Types::Alias
+              if last == :name
+                queries << TypeNameQuery.new(name: nodes[0].name)
+              end
+            when RBS::AST::Declarations::Class::Super, RBS::AST::Declarations::Module::Self
+              if last == :name
+                queries << TypeNameQuery.new(name: nodes[0].name)
+              end
+            end
+          end
+        end
+
+        queries
+      end
+
+      def type_check_path(target:, path:, content:, line:, column:)
+        signature_service = type_check.signature_services[target.name]
+        subtyping = signature_service.current_subtyping or return
+        source = Source.parse(content, path: path, factory: subtyping.factory)
+        source = source.without_unrelated_defs(line: line, column: column)
+        [
+          Services::TypeCheckService.type_check(source: source, subtyping: subtyping),
+          signature_service
+        ]
+      rescue
+        nil
+      end
+
+      def constant_definition_in_rbs(name, locations:)
+        type_check.signature_services.each_value do |signature|
+          env = signature.latest_env
+
+          if entry = env.class_decls[name]
+            entry.decls.each do |d|
+              locations << d.decl.location[:name]
+            end
+          end
+
+          if entry = env.constant_decls[name]
+            locations << entry.decl.location[:name]
+          end
+        end
+
+        locations
+      end
+
+      def constant_definition_in_ruby(name, locations:)
+        type_check.source_files.each do |path, source|
+          if typing = source.typing
+            entry = typing.source_index.entry(constant: name)
+            entry.definitions.each do |node|
+              case node.type
+              when :class, :module
+                locations << node.children[0].location.expression
+              when :casgn
+                parent = node.children[0]
+                location =
+                  if parent
+                    parent.location.expression.join(node.location.name)
+                  else
+                    node.location.name
+                  end
+                locations << location
+              end
+            end
+          end
+        end
+
+        locations
+      end
+
+      def method_locations(name, in_ruby:, in_rbs:, locations:)
+        if in_ruby
+          type_check.source_files.each do |path, source|
+            if typing = source.typing
+              entry = typing.source_index.entry(method: name)
+
+              if entry.definitions.empty?
+                if name.is_a?(SingletonMethodName) && name.method_name == :new
+                  initialize = InstanceMethodName.new(method_name: :initialize, type_name: name.type_name)
+                  entry = typing.source_index.entry(method: initialize)
+                end
+              end
+
+              entry.definitions.each do |node|
+                case node.type
+                when :def
+                  locations << node.location.name
+                when :defs
+                  locations << node.location.name
+                end
+              end
+            end
+          end
+        end
+
+        if in_rbs
+          type_check.signature_services.each_value do |signature|
+            index = signature.latest_rbs_index
+
+            entry = index.entry(method_name: name)
+
+            if entry.declarations.empty?
+              if name.is_a?(SingletonMethodName) && name.method_name == :new
+                initialize = InstanceMethodName.new(method_name: :initialize, type_name: name.type_name)
+                entry = index.entry(method_name: initialize)
+              end
+            end
+
+            entry.declarations.each do |decl|
+              case decl
+              when RBS::AST::Members::MethodDefinition
+                locations << decl.location[:name]
+              when RBS::AST::Members::Alias
+                locations << decl.location[:new_name]
+              when RBS::AST::Members::AttrAccessor, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrWriter
+                locations << decl.location[:name]
+              end
+            end
+          end
+        end
+
+        locations
+      end
+
+      def type_name_locations(name, locations: [])
+        type_check.signature_services.each_value do |signature|
+          index = signature.latest_rbs_index
+
+          entry = index.entry(type_name: name)
+          entry.declarations.each do |decl|
+            locations << decl.location[:name]
+          end
+        end
+
+        locations
+      end
+    end
+  end
+end

data/lib/steep/services/hover_content.rb

@@ -5,6 +5,10 @@ module Steep
       VariableContent = Struct.new(:node, :name, :type, :location, keyword_init: true)
       MethodCallContent = Struct.new(:node, :method_name, :type, :definition, :location, keyword_init: true)
       DefinitionContent = Struct.new(:node, :method_name, :method_type, :definition, :location, keyword_init: true) do
+      TypeAliasContent = Struct.new(:location, :decl, keyword_init: true)
+      ClassContent = Struct.new(:location, :decl, keyword_init: true)
+      InterfaceContent = Struct.new(:location, :decl, keyword_init: true)
+
         def comment_string
           if comments = definition&.comments
             comments.map {|c| c.string.chomp }.uniq.join("\n----\n")
@@ -50,99 +54,147 @@ module Steep
       end
 
       def content_for(path:, line:, column:)
-        target = project.target_for_source_path(path)
+        target_for_code, targets_for_sigs = project.targets_for_path(path)
+
+        case
+        when target = target_for_code
+          Steep.logger.info "target #{target}"
+
+          hover_for_source(column, line, path, target)
+
+        when target = targets_for_sigs[0]
+          service = self.service.signature_services[target.name]
+
+          _buffer, decls = service.latest_env.buffers_decls.find do |buffer, _|
+            Pathname(buffer.name) == path
+          end
+
+          return if decls.nil?
+
+          locator = RBS::Locator.new(decls: decls)
+          hd, tail = locator.find2(line: line, column: column)
+
+          case type = tail[0]
+          when RBS::Types::Alias
+            alias_decl = service.latest_env.alias_decls[type.name]&.decl or raise
+
+            location = tail[0].location
+            TypeAliasContent.new(
+              location: location,
+              decl: alias_decl
+            )
+          when RBS::Types::ClassInstance, RBS::Types::ClassSingleton
+            if hd == :name
+              env = service.latest_env
+              class_decl = env.class_decls[type.name]&.decls[0]&.decl or raise
+              location = tail[0].location[:name]
+              ClassContent.new(
+                location: location,
+                decl: class_decl
+              )
+            end
+          when RBS::Types::Interface
+            env = service.latest_env
+            interface_decl = env.interface_decls[type.name]&.decl or raise
+            location = type.location[:name]
+
+            InterfaceContent.new(
+              location: location,
+              decl: interface_decl
+            )
+          end
+        end
+      end
 
-        if target
-          file = service.source_files[path]
-          typing = typecheck(target, path: path, content: file.content, line: line, column: column) or return
+      def hover_for_source(column, line, path, target)
+        file = service.source_files[path]
+        typing = typecheck(target, path: path, content: file.content, line: line, column: column) or return
+        node, *parents = typing.source.find_nodes(line: line, column: column)
 
-          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] || AST::Types::Any.new(location: nil)
 
-          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] || AST::Types::Any.new(location: nil)
+            VariableContent.new(node: node, name: var_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] || typing.type_of(node: rhs)
 
-              VariableContent.new(node: node, name: var_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] || typing.type_of(node: rhs)
+            VariableContent.new(node: node, name: var_name, type: type, location: node.location.name)
+          when :send
+            receiver, method_name, *_ = node.children
 
-              VariableContent.new(node: node, name: var_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 = typing.context_at(line: line, column: column)
-
-              receiver_type = if receiver
-                                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: 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,
-                  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(
+                                      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