steep 1.10.0 → 2.0.0

data/lib/steep/services/content_change.rb

@@ -41,12 +41,25 @@ module Steep
         new(text: string)
       end
 
+      def self.from_lsp(changes)
+        changes.map do |change|
+          content_range =
+            if range = change[:range]
+              [
+                range[:start].yield_self {|pos| Services::ContentChange::Position.new(line: pos[:line] + 1, column: pos[:character]) },
+                end_pos = range[:end].yield_self {|pos| Services::ContentChange::Position.new(line: pos[:line] + 1, column: pos[:character]) }
+              ] #: range
+            end
+          Services::ContentChange.new(range: content_range, text: change[:text])
+        end
+      end
+
       def apply_to(text)
         if range
           text = text.dup
           start_pos, end_pos = range
 
-          buf = RBS::Buffer.new(name: :_, content: text)
+          buf = RBS::Buffer.new(name: Pathname("_"), content: text)
           start_pos = buf.loc_to_pos([start_pos.line, start_pos.column])
           end_pos = buf.loc_to_pos([end_pos.line, end_pos.column])
 

data/lib/steep/services/file_loader.rb

@@ -20,10 +20,12 @@ module Steep
 
           target.groups.each do |group|
             each_path_in_patterns(group.source_pattern, command_line_patterns, &handler)
+            each_path_in_patterns(group.inline_source_pattern, command_line_patterns, &handler)
             each_path_in_patterns(group.signature_pattern, &handler)
           end
 
           each_path_in_patterns(target.source_pattern, command_line_patterns, &handler)
+          each_path_in_patterns(target.inline_source_pattern, command_line_patterns, &handler)
           each_path_in_patterns(target.signature_pattern, &handler)
         else
           enum_for :each_path_in_target, target, command_line_patterns
@@ -35,14 +37,14 @@ module Steep
           pats = commandline_patterns.empty? ? pattern.patterns : commandline_patterns
 
           pats.each do |path|
-            Pathname.glob((base_dir + path).to_s).each do |absolute_path|
+            Pathname(base_dir).glob(path.to_s).each do |absolute_path|
               if absolute_path.file?
                 relative_path = absolute_path.relative_path_from(base_dir)
                 if pattern =~ relative_path
                   yield relative_path
                 end
               else
-                files = Pathname.glob("#{absolute_path}/**/*#{pattern.ext}")
+                files = Pathname(absolute_path).glob("**/*#{pattern.ext}")
 
                 files.sort.each do |source_path|
                   if source_path.file?

data/lib/steep/services/goto_service.rb

@@ -33,6 +33,126 @@ module Steep
         type_check.project
       end
 
+      # Parses a string representing a class/type/constant/method name into a query value.
+      #
+      # Supported formats:
+      #
+      # * `RBS::Location`                   -- type name (class, module, interface, type alias, class/module alias, or constant)
+      # * `::RBS::Location`                 -- type name, fully qualified
+      # * `RBS::Parser#parse_type`          -- instance method
+      # * `RBS::Parser.parse_signature`     -- singleton method
+      #
+      # Returns `nil` when the given string cannot be parsed as any of the above.
+      #
+      def self.parse_name(name_string)
+        return nil if name_string.nil? || name_string.empty?
+
+        if index = name_string.index("#")
+          type_part = name_string[0...index] or return nil
+          method_part = name_string[(index + 1)..] or return nil
+          return nil if type_part.empty? || method_part.empty?
+
+          type_name = parse_type_name(type_part) or return nil
+          InstanceMethodName.new(type_name: type_name, method_name: method_part.to_sym)
+        elsif index = find_singleton_method_dot(name_string)
+          type_part = name_string[0...index] or return nil
+          method_part = name_string[(index + 1)..] or return nil
+          return nil if type_part.empty? || method_part.empty?
+
+          type_name = parse_type_name(type_part) or return nil
+          SingletonMethodName.new(type_name: type_name, method_name: method_part.to_sym)
+        else
+          parse_type_name(name_string)
+        end
+      rescue RBS::ParsingError, StandardError
+        nil
+      end
+
+      # Finds the index of a `.` that separates a type from a singleton method name.
+      #
+      # Returns the index of the last `.` that is *not* followed by another `.` (to avoid
+      # matching the empty string) and that is not part of `::`. Returns `nil` if none is found.
+      #
+      def self.find_singleton_method_dot(string)
+        index = string.length - 1
+        while index > 0
+          char = string[index]
+          if char == "."
+            prev = string[index - 1]
+            if prev != "." && prev != ":"
+              return index
+            end
+          end
+          index -= 1
+        end
+        nil
+      end
+
+      def self.parse_type_name(string)
+        string = "::#{string}" unless string.start_with?("::")
+        RBS::TypeName.parse(string)
+      rescue RBS::ParsingError, StandardError
+        nil
+      end
+
+      # Returns array of locations that is a response to a *Query definition* request.
+      #
+      # Unlike `#definition`, this method takes a parsed name value instead of a source position.
+      # The caller is expected to parse the name via `.parse_name` before calling this method.
+      #
+      # Each returned entry is either an `RBS::Location` (for RBS declarations) or a
+      # `Parser::Source::Range` (for Ruby source locations).
+      #
+      def query_definition(name)
+        locations = [] #: Array[target_loc]
+
+        case name
+        when RBS::TypeName
+          # `constant_definition_in_rbs` covers classes, modules, class/module aliases,
+          # and plain constants (via `env.constant_entry`).
+          constant_definition_in_rbs(name, locations: locations)
+          constant_definition_in_ruby(name, locations: locations)
+          # Additional lookups for declarations that are not reachable via `env.constant_entry`.
+          interface_and_type_alias_locations(name, locations: locations)
+        when InstanceMethodName, SingletonMethodName
+          method_locations(name, in_ruby: true, in_rbs: true, locations: locations)
+        end
+
+        locations.filter_map do |target, loc|
+          case loc
+          when RBS::Location
+            if assignment =~ [target, loc.name]
+              loc
+            end
+          else
+            loc
+          end
+        end.uniq
+      end
+
+      def interface_and_type_alias_locations(name, locations:)
+        project.targets.each do |target|
+          signature = type_check.signature_services.fetch(target.name)
+          env = signature.latest_env
+
+          if entry = env.interface_decls[name]
+            decl = entry.decl
+            if loc = decl.location
+              locations << [target, loc[:name]]
+            end
+          end
+
+          if entry = env.type_alias_decls[name]
+            decl = entry.decl
+            if loc = decl.location
+              locations << [target, loc[:name]]
+            end
+          end
+        end
+
+        locations
+      end
+
       def implementation(path:, line:, column:)
         locations = [] #: Array[target_loc]
 
@@ -162,75 +282,46 @@ module Steep
         relative_path = project.relative_path(path)
 
         case
-        when target = type_check.project.target_for_source_path(relative_path)
-          source = type_check.source_files.fetch(relative_path, nil) or return []
-          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)
+        when target = type_check.project.target_for_inline_source_path(relative_path)
+          signature = type_check.signature_services.fetch(target.name)
+          source = signature.latest_env.sources.find do
+            if _1.is_a?(::RBS::Source::Ruby)
+              _1.buffer.name == relative_path
+            end
+          end
 
-            if node && parents
-              case node.type
-              when :const, :casgn
-                named_location = (_ = node.location) #: Parser::AST::_NamedLocation
-                if test_ast_location(named_location.name, line: line, column: column)
-                  if name = typing.source_index.reference(constant_node: node)
-                    queries << ConstantQuery.new(name: name, from: :ruby)
-                  end
-                end
-              when :def, :defs
-                named_location = (_ = node.location) #: Parser::AST::_NamedLocation
-                if test_ast_location(named_location.name, line: line, column: column)
-                  if method_context = typing.cursor_context.context&.method_context
-                    if method = method_context.method
-                      method.defs.each do |defn|
-                        singleton_method =
-                          case defn.member
-                          when RBS::AST::Members::MethodDefinition
-                            defn.member.singleton?
-                          when RBS::AST::Members::Attribute
-                            defn.member.kind == :singleton
-                          end
-
-                        name =
-                          if singleton_method
-                            SingletonMethodName.new(type_name: defn.defined_in, method_name: method_context.name)
-                          else
-                            InstanceMethodName.new(type_name: defn.defined_in, method_name: method_context.name)
-                          end
-
-                        queries << MethodQuery.new(name: name, from: :ruby)
-                      end
-                    end
-                  end
-                end
-              when :send
-                location = (_ = node.location) #: Parser::AST::_SelectorLocation
-                if test_ast_location(location.selector, line: line, column: column)
-                  if (parent = parents[0]) && parent.type == :block && parent.children[0] == node
-                    node = parents[0]
-                  end
+          if source.is_a?(::RBS::Source::Ruby)
+            locator = Locator::Inline.new(source)
+            result = locator.find(line, column)
 
-                  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
+            case result
+            when Locator::InlineTypeNameResult
+              queries << TypeNameQuery.new(name: result.type_name)
+            end
+          end
+
+          if queries.empty?
+            source = type_check.source_files.fetch(relative_path, nil) or return []
+            typing, signature, subtyping = type_check_path(target: target, path: relative_path, content: source.content, line: line, column: column)
+            if typing && signature && subtyping
+              queries.concat query_at_implementation(typing, subtyping, line: line, column: column)
             end
           end
+        when target = type_check.project.target_for_source_path(relative_path)
+          source = type_check.source_files.fetch(relative_path, nil) or return []
+          typing, _signature, subtyping = type_check_path(target: target, path: relative_path, content: source.content, line: line, column: column)
+          if typing && subtyping
+            queries.concat query_at_implementation(typing, subtyping, line: line, column: column)
+          end
         when target_names = type_check.signature_file?(path) #: Array[Symbol]
           target_names.each do |target_name|
             signature_service = type_check.signature_services[target_name] #: SignatureService
 
             env = signature_service.latest_env
-            buffer = env.buffers.find {|buf| buf.name.to_s == relative_path.to_s } or raise
-            (dirs, decls = env.signatures[buffer]) or raise
+            source = env.each_rbs_source.find {|src| src.buffer.name == relative_path } or raise
+            buffer = source.buffer
+            dirs = source.directives
+            decls = source.declarations
 
             locator = RBS::Locator.new(buffer: buffer, dirs: dirs, decls: decls)
             last, nodes = locator.find2(line: line, column: column)
@@ -283,6 +374,93 @@ module Steep
         queries
       end
 
+      def query_at_implementation(typing, subtyping, line:, column:)
+        queries = [] #: Array[query]
+
+        locator = Locator::Ruby.new(typing.source)
+        result = locator.find(line, column)
+
+        case result
+        when Locator::NodeResult
+          node = result.node
+          parents = result.parents
+
+          case node.type
+          when :const, :casgn
+            named_location = (_ = node.location) #: Parser::AST::_NamedLocation
+            if test_ast_location(named_location.name, line: line, column: column)
+              if name = typing.source_index.reference(constant_node: node)
+                queries << ConstantQuery.new(name: name, from: :ruby)
+              end
+            end
+          when :def, :defs
+            named_location = (_ = node.location) #: Parser::AST::_NamedLocation
+            if test_ast_location(named_location.name, line: line, column: column)
+              if method_context = typing.cursor_context.context&.method_context
+                if method = method_context.method
+                  method.defs.each do |defn|
+                    singleton_method =
+                      case defn.member
+                      when RBS::AST::Members::MethodDefinition
+                        defn.member.singleton?
+                      when RBS::AST::Members::Attribute
+                        defn.member.kind == :singleton
+                      end
+
+                    name =
+                      if singleton_method
+                        SingletonMethodName.new(type_name: defn.defined_in, method_name: method_context.name)
+                      else
+                        InstanceMethodName.new(type_name: defn.defined_in, method_name: method_context.name)
+                      end
+
+                    queries << MethodQuery.new(name: name, from: :ruby)
+                  end
+                end
+              end
+            end
+          when :send
+            location = (_ = node.location) #: Parser::AST::_SelectorLocation
+            if test_ast_location(location.selector, line: line, column: column)
+              if (parent = parents[0]) && parent.type == :block && parent.children[0] === node
+                node = parents[0]
+              end
+
+              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
+        when Locator::TypeAssertionResult
+          context = typing.cursor_context.context or raise
+          nesting = context.module_context.nesting
+          type_vars = context.variable_context.type_params.map(&:name)
+          pos = typing.source.buffer.loc_to_pos([line, column])
+
+          if pair = result.locate_type_name(pos, nesting, subtyping, type_vars)
+            queries << TypeNameQuery.new(name: pair[0])
+          end
+        when Locator::TypeApplicationResult
+          context = typing.cursor_context.context or raise
+          nesting = context.module_context.nesting
+          type_vars = context.variable_context.type_params.map(&:name)
+          pos = typing.source.buffer.loc_to_pos([line, column])
+
+          if pair = result.locate_type_name(pos, nesting, subtyping, type_vars)
+            queries << TypeNameQuery.new(name: pair[0])
+          end
+        end
+
+        queries
+      end
+
       def type_check_path(target:, path:, content:, line:, column:)
         signature_service = type_check.signature_services.fetch(target.name)
         subtyping = signature_service.current_subtyping or return
@@ -292,7 +470,8 @@ module Steep
         loc = source.buffer.loc_to_pos([line, column])
         [
           Services::TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver, cursor: loc),
-          signature_service
+          signature_service,
+          subtyping
         ]
       rescue
         nil
@@ -305,18 +484,36 @@ module Steep
 
           case entry = env.constant_entry(name)
           when RBS::Environment::ConstantEntry
-            if entry.decl.location
-              locations << [target, entry.decl.location[:name]]
+            case decl = entry.decl
+            when RBS::AST::Declarations::Constant
+              if entry.decl.location
+                locations << [target, entry.decl.location[:name]]
+              end
+            when RBS::AST::Ruby::Declarations::ConstantDecl
+              locations << [target, entry.decl.name_location]
+            else
+              raise "Unknown declaration: #{entry.decl.inspect}"
             end
           when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
-            entry.decls.each do |d|
-              if d.decl.location
-                locations << [target, d.decl.location[:name]]
+            entry.each_decl do |decl|
+              case decl
+              when RBS::AST::Declarations::Base
+                if decl.location
+                  locations << [target, decl.location[:name]]
+                end
+              when RBS::AST::Ruby::Declarations::ClassDecl, RBS::AST::Ruby::Declarations::ModuleDecl
+                locations << [target, decl.name_location]
+              else
+                raise "Unknown declaration: #{decl.inspect}"
               end
             end
           when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
-            if entry.decl.location
-              locations << [target, entry.decl.location[:new_name]]
+            if entry.decl.is_a?(RBS::AST::Declarations::Base)
+              if entry.decl.location
+                locations << [target, entry.decl.location[:new_name]]
+              end
+            else
+              locations << [target, entry.decl.name_location]
             end
           end
         end
@@ -404,6 +601,8 @@ module Steep
                 if decl.location
                   locations << [target, decl.location[:name]]
                 end
+              when RBS::AST::Ruby::Members::DefMember
+                locations << [target, decl.name_location]
               end
             end
           end
@@ -428,6 +627,10 @@ module Steep
               if decl.location
                 locations << [target, decl.location[:new_name]]
               end
+            when RBS::AST::Ruby::Declarations::ClassDecl, RBS::AST::Ruby::Declarations::ModuleDecl
+              locations << [target, decl.name_location]
+            when RBS::AST::Ruby::Declarations::ClassModuleAliasDecl
+              locations << [target, decl.name_location]
             else
               raise
             end

data/lib/steep/services/hover_provider/content.rb

@@ -0,0 +1,67 @@
+module Steep
+  module Services
+    module HoverProvider
+      TypeContent = _ = Struct.new(:node, :type, :location, keyword_init: true)
+      VariableContent = _ = Struct.new(:node, :name, :type, :location, keyword_init: true)
+      TypeAssertionContent = _ = Struct.new(:node, :original_type, :asserted_type, :location, keyword_init: true)
+      MethodCallContent = _ = Struct.new(:node, :method_call, :location, keyword_init: true)
+      DefinitionContent = _ = Struct.new(:node, :method_name, :method_type, :definition, :location, keyword_init: true)
+      ConstantContent = _ = Struct.new(:location, :full_name, :type, :decl, keyword_init: true) do
+        # @implements ConstantContent
+
+          def comments
+            case
+            when decl = class_decl
+              decl.each_decl.map do |decl|
+                case decl
+                when ::RBS::AST::Declarations::Base
+                  decl.comment
+                when ::RBS::AST::Ruby::Declarations::Base
+                  nil
+                end
+
+              end
+            when decl = class_alias
+              [decl.decl.comment]
+            when decl = constant_decl
+              [decl.decl.comment]
+            else
+              raise
+            end.compact
+          end
+
+          def class_decl
+            case decl
+            when ::RBS::Environment::ClassEntry, ::RBS::Environment::ModuleEntry
+              decl
+            end
+          end
+
+          def class_alias
+            case decl
+            when ::RBS::Environment::ClassAliasEntry, ::RBS::Environment::ModuleAliasEntry
+              decl
+            end
+          end
+
+          def constant_decl
+            if decl.is_a?(::RBS::Environment::ConstantEntry)
+              decl
+            end
+          end
+
+          def constant?
+            constant_decl ? true : false
+          end
+
+          def class_or_module?
+            (class_decl || class_alias) ?  true : false
+        end
+      end
+
+      TypeAliasContent = _ = Struct.new(:location, :decl, keyword_init: true)
+      ClassTypeContent = _ = Struct.new(:location, :decl, keyword_init: true)
+      InterfaceTypeContent = _ = Struct.new(:location, :decl, keyword_init: true)
+    end
+  end
+end

data/lib/steep/services/hover_provider/rbs.rb

@@ -1,11 +1,8 @@
 module Steep
   module Services
     module HoverProvider
-      class RBS
-        TypeAliasContent = _ = Struct.new(:location, :decl, keyword_init: true)
-        ClassContent = _ = Struct.new(:location, :decl, keyword_init: true)
-        InterfaceContent = _ = Struct.new(:location, :decl, keyword_init: true)
 
+      class RBS
         attr_reader :service
 
         def initialize(service:)
@@ -20,8 +17,10 @@ module Steep
           service = self.service.signature_services.fetch(target.name)
 
           env = service.latest_env
-          buffer = env.buffers.find {|buf| buf.name.to_s == path.to_s } or return
-          (dirs, decls = env.signatures[buffer]) or raise
+          source = env.each_rbs_source.find {|src| src.buffer.name == path } or return
+          buffer = source.buffer
+          dirs = source.directives
+          decls = source.declarations
 
           locator = ::RBS::Locator.new(buffer: buffer, dirs: dirs, decls: decls)
           loc_key, path = locator.find2(line: line, column: column) || return
@@ -68,18 +67,18 @@ module Steep
             TypeAliasContent.new(location: location, decl: alias_decl)
           when type_name.interface?
             interface_decl = env.interface_decls[type_name]&.decl or return
-            InterfaceContent.new(location: location, decl: interface_decl)
+            InterfaceTypeContent.new(location: location, decl: interface_decl)
           when type_name.class?
             class_entry = env.module_class_entry(type_name) or return
 
             case class_entry
             when ::RBS::Environment::ClassEntry, ::RBS::Environment::ModuleEntry
-              class_decl = class_entry.primary.decl
+              class_decl = class_entry.primary_decl
             when ::RBS::Environment::ClassAliasEntry, ::RBS::Environment::ModuleAliasEntry
               class_decl = class_entry.decl
             end
 
-            ClassContent.new(location: location, decl: class_decl)
+            ClassTypeContent.new(location: location, decl: class_decl)
           end
         end
       end