ruby-lsp 0.17.13 → 0.17.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 042725d7afce428b5c024933a7101151f2f69c57cbb40b4f938384c13d6c974b
-  data.tar.gz: bec8636d402451e1009e87ddd98e6fdedc062643e614b596a0698ffcfcc9b271
+  metadata.gz: 43d715172510bba67801670dbfc574eed9851b9852aaea3f6e210acd74734af4
+  data.tar.gz: b35b3a55c3d65987390e4b125a090ff8f6da902bfa7ab9c08eb9eb8c72d5157f
 SHA512:
-  metadata.gz: 6a6adb40a9ccaaf916f46c041f3eb2cc7a81be73c5d3bf7c05a45472cd9d08e5a9dd04d804b8e15f091645d420037e324368ccbcc619311a1c60c81f241c1b89
-  data.tar.gz: d6b19c8d02cfab8dca9e4d675e8ee549e8b392631a6080757c0413da29a07d1db411d9360b7553a798805d9e6faac7318863e35ba664488c5eb41c869a7e734a
+  metadata.gz: ef8a2ca24755eef8c5ed1146f1f6c40ec725988e9dd6a51efb326583e5606a221f733625f08d4dad5bb6091675c39fb18a485ff8c0bed1dc0b2e221a4390c585
+  data.tar.gz: 16101462585105a9a201f6341908f0b238f77f4acaa6dac723c95e35fcddc7c7b68d937bead5beecc14ae6bcac276b2f813523304f7eaded3132d3aa07eb943b

data/VERSION

@@ -1 +1 @@
-0.17.13
+0.17.15

data/exe/ruby-lsp

@@ -81,6 +81,8 @@ require "ruby_lsp/load_sorbet"
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 require "ruby_lsp/internal"
 
+T::Utils.run_all_sig_blocks
+
 if options[:debug]
   if ["x64-mingw-ucrt", "x64-mingw32"].include?(RUBY_PLATFORM)
     $stderr.puts "Debugging is not supported on Windows"

data/lib/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -16,15 +16,24 @@ module RubyIndexer
       T::Hash[String, T.untyped],
     )
 
+    sig { params(workspace_path: String).void }
+    attr_writer :workspace_path
+
     sig { void }
     def initialize
+      @workspace_path = T.let(Dir.pwd, String)
       @excluded_gems = T.let(initial_excluded_gems, T::Array[String])
       @included_gems = T.let([], T::Array[String])
-      @excluded_patterns = T.let([File.join("**", "*_test.rb"), File.join("**", "tmp", "**", "*")], T::Array[String])
+      @excluded_patterns = T.let([File.join("**", "*_test.rb"), File.join("tmp", "**", "*")], T::Array[String])
+
       path = Bundler.settings["path"]
-      @excluded_patterns << File.join(File.expand_path(path, Dir.pwd), "**", "*.rb") if path
+      if path
+        # Substitute Windows backslashes into forward slashes, which are used in glob patterns
+        glob = path.gsub(/[\\]+/, "/")
+        @excluded_patterns << File.join(glob, "**", "*.rb")
+      end
 
-      @included_patterns = T.let([File.join(Dir.pwd, "**", "*.rb")], T::Array[String])
+      @included_patterns = T.let([File.join("**", "*.rb")], T::Array[String])
       @excluded_magic_comments = T.let(
         [
           "frozen_string_literal:",
@@ -55,12 +64,12 @@ module RubyIndexer
       indexables = @included_patterns.flat_map do |pattern|
         load_path_entry = T.let(nil, T.nilable(String))
 
-        Dir.glob(pattern, File::FNM_PATHNAME | File::FNM_EXTGLOB).map! do |path|
+        Dir.glob(File.join(@workspace_path, pattern), File::FNM_PATHNAME | File::FNM_EXTGLOB).map! do |path|
           path = File.expand_path(path)
           # All entries for the same pattern match the same $LOAD_PATH entry. Since searching the $LOAD_PATH for every
           # entry is expensive, we memoize it until we find a path that doesn't belong to that $LOAD_PATH. This happens
-          # on repositories that define multiple gems, like Rails. All frameworks are defined inside the Dir.pwd, but
-          # each one of them belongs to a different $LOAD_PATH entry
+          # on repositories that define multiple gems, like Rails. All frameworks are defined inside the current
+          # workspace directory, but each one of them belongs to a different $LOAD_PATH entry
           if load_path_entry.nil? || !path.start_with?(load_path_entry)
             load_path_entry = $LOAD_PATH.find { |load_path| path.start_with?(load_path) }
           end
@@ -69,9 +78,19 @@ module RubyIndexer
         end
       end
 
+      # If the patterns are relative, we make it relative to the workspace path. If they are absolute, then we shouldn't
+      # concatenate anything
+      excluded_patterns = @excluded_patterns.map do |pattern|
+        if File.absolute_path?(pattern)
+          pattern
+        else
+          File.join(@workspace_path, pattern)
+        end
+      end
+
       # Remove user specified patterns
       indexables.reject! do |indexable|
-        @excluded_patterns.any? do |pattern|
+        excluded_patterns.any? do |pattern|
           File.fnmatch?(pattern, indexable.full_path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
         end
       end
@@ -122,7 +141,7 @@ module RubyIndexer
         # When working on a gem, it will be included in the locked_gems list. Since these are the project's own files,
         # we have already included and handled exclude patterns for it and should not re-include or it'll lead to
         # duplicates or accidentally ignoring exclude patterns
-        next if spec.full_gem_path == Dir.pwd
+        next if spec.full_gem_path == @workspace_path
 
         indexables.concat(
           spec.require_paths.flat_map do |require_path|
@@ -185,7 +204,7 @@ module RubyIndexer
       # If the dependency is prerelease, `to_spec` may return `nil` due to a bug in older version of Bundler/RubyGems:
       # https://github.com/Shopify/ruby-lsp/issues/1246
       this_gem = Bundler.definition.dependencies.find do |d|
-        d.to_spec&.full_gem_path == Dir.pwd
+        d.to_spec&.full_gem_path == @workspace_path
       rescue Gem::MissingSpecError
         false
       end

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -152,16 +152,17 @@ module RubyIndexer
 
       if current_owner
         expression = node.expression
-        @stack << (expression.is_a?(Prism::SelfNode) ? "<Class:#{@stack.last}>" : "<Class:#{expression.slice}>")
+        name = (expression.is_a?(Prism::SelfNode) ? "<Class:#{@stack.last}>" : "<Class:#{expression.slice}>")
+        real_nesting = actual_nesting(name)
 
-        existing_entries = T.cast(@index[@stack.join("::")], T.nilable(T::Array[Entry::SingletonClass]))
+        existing_entries = T.cast(@index[real_nesting.join("::")], T.nilable(T::Array[Entry::SingletonClass]))
 
         if existing_entries
           entry = T.must(existing_entries.first)
           entry.update_singleton_information(node.location, expression.location, collect_comments(node))
         else
           entry = Entry::SingletonClass.new(
-            @stack,
+            real_nesting,
             @file_path,
             node.location,
             expression.location,
@@ -172,6 +173,7 @@ module RubyIndexer
         end
 
         @owner_stack << entry
+        @stack << name
       end
     end
 

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -564,6 +564,27 @@ module RubyIndexer
       assert_entry("Foo::Bar", Entry::Class, "/fake/path/foo.rb:1-2:2-5")
     end
 
+    def test_indexing_singletons_inside_top_level_references
+      index(<<~RUBY)
+        module ::Foo
+          class Bar
+            class << self
+            end
+          end
+        end
+      RUBY
+
+      # We want to explicitly verify that we didn't introduce the leading `::` by accident, but `Index#[]` deletes the
+      # prefix when we use `refute_entry`
+      entries = @index.instance_variable_get(:@entries)
+      refute(entries.key?("::Foo"))
+      refute(entries.key?("::Foo::Bar"))
+      refute(entries.key?("::Foo::Bar::<Class:Bar>"))
+      assert_entry("Foo", Entry::Module, "/fake/path/foo.rb:0-0:5-3")
+      assert_entry("Foo::Bar", Entry::Class, "/fake/path/foo.rb:1-2:4-5")
+      assert_entry("Foo::Bar::<Class:Bar>", Entry::SingletonClass, "/fake/path/foo.rb:2-4:3-7")
+    end
+
     def test_indexing_namespaces_inside_nested_top_level_references
       index(<<~RUBY)
         class Baz

data/lib/ruby_indexer/test/configuration_test.rb

@@ -7,10 +7,12 @@ module RubyIndexer
   class ConfigurationTest < Minitest::Test
     def setup
       @config = Configuration.new
+      @workspace_path = File.expand_path(File.join("..", "..", ".."), __dir__)
+      @config.workspace_path = @workspace_path
     end
 
     def test_load_configuration_executes_configure_block
-      @config.apply_config({ "excluded_patterns" => ["**/test/fixtures/**/*.rb"] })
+      @config.apply_config({ "excluded_patterns" => ["**/fixtures/**/*.rb"] })
       indexables = @config.indexables
 
       assert(indexables.none? { |indexable| indexable.full_path.include?("test/fixtures") })
@@ -25,7 +27,7 @@ module RubyIndexer
       indexables = @config.indexables
 
       # All paths should be expanded
-      assert(indexables.none? { |indexable| indexable.full_path.start_with?("lib/") })
+      assert(indexables.all? { |indexable| File.absolute_path?(indexable.full_path) })
     end
 
     def test_indexables_only_includes_gem_require_paths
@@ -71,17 +73,20 @@ module RubyIndexer
       Bundler.settings.temporary(path: "vendor/bundle") do
         config = Configuration.new
 
-        assert_includes(config.instance_variable_get(:@excluded_patterns), "#{Dir.pwd}/vendor/bundle/**/*.rb")
+        assert_includes(config.instance_variable_get(:@excluded_patterns), "vendor/bundle/**/*.rb")
       end
     end
 
     def test_indexables_does_not_include_gems_own_installed_files
       indexables = @config.indexables
+      indexables_inside_bundled_lsp = indexables.select do |indexable|
+        indexable.full_path.start_with?(Bundler.bundle_path.join("gems", "ruby-lsp").to_s)
+      end
 
-      assert(
-        indexables.none? do |indexable|
-          indexable.full_path.start_with?(Bundler.bundle_path.join("gems", "ruby-lsp").to_s)
-        end,
+      assert_empty(
+        indexables_inside_bundled_lsp,
+        "Indexables should not include files from the gem currently being worked on. " \
+          "Included: #{indexables_inside_bundled_lsp.map(&:full_path)}",
       )
     end
 
@@ -126,5 +131,34 @@ module RubyIndexer
         assert_match(regex, comment)
       end
     end
+
+    def test_indexables_respect_given_workspace_path
+      Dir.mktmpdir do |dir|
+        FileUtils.mkdir(File.join(dir, "ignore"))
+        FileUtils.touch(File.join(dir, "ignore", "file0.rb"))
+        FileUtils.touch(File.join(dir, "file1.rb"))
+        FileUtils.touch(File.join(dir, "file2.rb"))
+
+        @config.apply_config({ "excluded_patterns" => ["ignore/**/*.rb"] })
+        @config.workspace_path = dir
+        indexables = @config.indexables
+
+        assert(indexables.none? { |indexable| indexable.full_path.start_with?(File.join(dir, "ignore")) })
+
+        # After switching the workspace path, all indexables will be found in one of these places:
+        # - The new workspace path
+        # - The Ruby LSP's own code (because Bundler is requiring the dependency from source)
+        # - Bundled gems
+        # - Default gems
+        assert(
+          indexables.all? do |i|
+            i.full_path.start_with?(dir) ||
+            i.full_path.start_with?(File.join(Dir.pwd, "lib")) ||
+            i.full_path.start_with?(Bundler.bundle_path.to_s) ||
+            i.full_path.start_with?(RbConfig::CONFIG["rubylibdir"])
+          end,
+        )
+      end
+    end
   end
 end

data/lib/ruby_lsp/document.rb

@@ -7,15 +7,19 @@ module RubyLsp
       enums do
         Ruby = new("ruby")
         ERB = new("erb")
+        RBS = new("rbs")
       end
     end
 
     extend T::Sig
     extend T::Helpers
+    extend T::Generic
+
+    ParseResultType = type_member
 
     abstract!
 
-    sig { returns(Prism::ParseResult) }
+    sig { returns(ParseResultType) }
     attr_reader :parse_result
 
     sig { returns(String) }
@@ -38,10 +42,10 @@ module RubyLsp
       @version = T.let(version, Integer)
       @uri = T.let(uri, URI::Generic)
       @needs_parsing = T.let(true, T::Boolean)
-      @parse_result = T.let(parse, Prism::ParseResult)
+      @parse_result = T.let(parse, ParseResultType)
     end
 
-    sig { params(other: Document).returns(T::Boolean) }
+    sig { params(other: Document[T.untyped]).returns(T::Boolean) }
     def ==(other)
       self.class == other.class && uri == other.uri && @source == other.source
     end
@@ -54,7 +58,7 @@ module RubyLsp
       type_parameters(:T)
         .params(
           request_name: String,
-          block: T.proc.params(document: Document).returns(T.type_parameter(:T)),
+          block: T.proc.params(document: Document[ParseResultType]).returns(T.type_parameter(:T)),
         ).returns(T.type_parameter(:T))
     end
     def cache_fetch(request_name, &block)
@@ -93,7 +97,7 @@ module RubyLsp
       @cache.clear
     end
 
-    sig { abstract.returns(Prism::ParseResult) }
+    sig { abstract.returns(ParseResultType) }
     def parse; end
 
     sig { abstract.returns(T::Boolean) }
@@ -104,115 +108,6 @@ module RubyLsp
       Scanner.new(@source, @encoding)
     end
 
-    sig do
-      params(
-        position: T::Hash[Symbol, T.untyped],
-        node_types: T::Array[T.class_of(Prism::Node)],
-      ).returns(NodeContext)
-    end
-    def locate_node(position, node_types: [])
-      locate(@parse_result.value, create_scanner.find_char_position(position), node_types: node_types)
-    end
-
-    sig do
-      params(
-        node: Prism::Node,
-        char_position: Integer,
-        node_types: T::Array[T.class_of(Prism::Node)],
-      ).returns(NodeContext)
-    end
-    def locate(node, char_position, node_types: [])
-      queue = T.let(node.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
-      closest = node
-      parent = T.let(nil, T.nilable(Prism::Node))
-      nesting_nodes = T.let(
-        [],
-        T::Array[T.any(
-          Prism::ClassNode,
-          Prism::ModuleNode,
-          Prism::SingletonClassNode,
-          Prism::DefNode,
-          Prism::BlockNode,
-          Prism::LambdaNode,
-          Prism::ProgramNode,
-        )],
-      )
-
-      nesting_nodes << node if node.is_a?(Prism::ProgramNode)
-      call_node = T.let(nil, T.nilable(Prism::CallNode))
-
-      until queue.empty?
-        candidate = queue.shift
-
-        # Skip nil child nodes
-        next if candidate.nil?
-
-        # Add the next child_nodes to the queue to be processed. The order here is important! We want to move in the
-        # same order as the visiting mechanism, which means searching the child nodes before moving on to the next
-        # sibling
-        T.unsafe(queue).unshift(*candidate.child_nodes)
-
-        # Skip if the current node doesn't cover the desired position
-        loc = candidate.location
-        next unless (loc.start_offset...loc.end_offset).cover?(char_position)
-
-        # If the node's start character is already past the position, then we should've found the closest node
-        # already
-        break if char_position < loc.start_offset
-
-        # If the candidate starts after the end of the previous nesting level, then we've exited that nesting level and
-        # need to pop the stack
-        previous_level = nesting_nodes.last
-        nesting_nodes.pop if previous_level && loc.start_offset > previous_level.location.end_offset
-
-        # Keep track of the nesting where we found the target. This is used to determine the fully qualified name of the
-        # target when it is a constant
-        case candidate
-        when Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode, Prism::DefNode, Prism::BlockNode,
-          Prism::LambdaNode
-          nesting_nodes << candidate
-        end
-
-        if candidate.is_a?(Prism::CallNode)
-          arg_loc = candidate.arguments&.location
-          blk_loc = candidate.block&.location
-          if (arg_loc && (arg_loc.start_offset...arg_loc.end_offset).cover?(char_position)) ||
-              (blk_loc && (blk_loc.start_offset...blk_loc.end_offset).cover?(char_position))
-            call_node = candidate
-          end
-        end
-
-        # If there are node types to filter by, and the current node is not one of those types, then skip it
-        next if node_types.any? && node_types.none? { |type| candidate.class == type }
-
-        # If the current node is narrower than or equal to the previous closest node, then it is more precise
-        closest_loc = closest.location
-        if loc.end_offset - loc.start_offset <= closest_loc.end_offset - closest_loc.start_offset
-          parent = closest
-          closest = candidate
-        end
-      end
-
-      # When targeting the constant part of a class/module definition, we do not want the nesting to be duplicated. That
-      # is, when targeting Bar in the following example:
-      #
-      # ```ruby
-      #   class Foo::Bar; end
-      # ```
-      # The correct target is `Foo::Bar` with an empty nesting. `Foo::Bar` should not appear in the nesting stack, even
-      # though the class/module node does indeed enclose the target, because it would lead to incorrect behavior
-      if closest.is_a?(Prism::ConstantReadNode) || closest.is_a?(Prism::ConstantPathNode)
-        last_level = nesting_nodes.last
-
-        if (last_level.is_a?(Prism::ModuleNode) || last_level.is_a?(Prism::ClassNode)) &&
-            last_level.constant_path == closest
-          nesting_nodes.pop
-        end
-      end
-
-      NodeContext.new(closest, parent, nesting_nodes, call_node)
-    end
-
     class Scanner
       extend T::Sig
 

data/lib/ruby_lsp/erb_document.rb

@@ -4,15 +4,19 @@
 module RubyLsp
   class ERBDocument < Document
     extend T::Sig
+    extend T::Generic
 
-    sig { override.returns(Prism::ParseResult) }
+    ParseResultType = type_member { { fixed: Prism::ParseResult } }
+
+    sig { override.returns(ParseResultType) }
     def parse
       return @parse_result unless @needs_parsing
 
       @needs_parsing = false
       scanner = ERBScanner.new(@source)
       scanner.scan
-      @parse_result = Prism.parse(scanner.ruby)
+      # assigning empty scopes to turn Prism into eval mode
+      @parse_result = Prism.parse(scanner.ruby, scopes: [[]])
     end
 
     sig { override.returns(T::Boolean) }
@@ -25,6 +29,16 @@ module RubyLsp
       LanguageId::ERB
     end
 
+    sig do
+      params(
+        position: T::Hash[Symbol, T.untyped],
+        node_types: T::Array[T.class_of(Prism::Node)],
+      ).returns(NodeContext)
+    end
+    def locate_node(position, node_types: [])
+      RubyDocument.locate(@parse_result.value, create_scanner.find_char_position(position), node_types: node_types)
+    end
+
     class ERBScanner
       extend T::Sig
 

data/lib/ruby_lsp/global_state.rb

@@ -93,7 +93,7 @@ module RubyLsp
       @test_library = detect_test_library(direct_dependencies)
       notifications << Notification.window_log_message("Detected test library: #{@test_library}")
 
-      @has_type_checker = detect_typechecker(direct_dependencies)
+      @has_type_checker = detect_typechecker(all_dependencies)
       if @has_type_checker
         notifications << Notification.window_log_message(
           "Ruby LSP detected this is a Sorbet project and will defer to the Sorbet LSP for some functionality",

data/lib/ruby_lsp/internal.rb

@@ -36,6 +36,7 @@ require "ruby_lsp/node_context"
 require "ruby_lsp/document"
 require "ruby_lsp/ruby_document"
 require "ruby_lsp/erb_document"
+require "ruby_lsp/rbs_document"
 require "ruby_lsp/store"
 require "ruby_lsp/addon"
 require "ruby_lsp/requests/support/rubocop_runner"

data/lib/ruby_lsp/listeners/definition.rb

@@ -208,10 +208,13 @@ module RubyLsp
       def handle_method_definition(message, receiver_type, inherited_only: false)
         methods = if receiver_type
           @index.resolve_method(message, receiver_type.name, inherited_only: inherited_only)
-        else
-          # If the method doesn't have a receiver, then we provide a few candidates to jump to
-          # But we don't want to provide too many candidates, as it can be overwhelming
-          @index[message]&.take(MAX_NUMBER_OF_DEFINITION_CANDIDATES_WITHOUT_RECEIVER)
+        end
+
+        # If the method doesn't have a receiver, or the guessed receiver doesn't have any matched candidates,
+        # then we provide a few candidates to jump to
+        # But we don't want to provide too many candidates, as it can be overwhelming
+        if receiver_type.nil? || (receiver_type.is_a?(TypeInferrer::GuessedType) && methods.nil?)
+          methods = @index[message]&.take(MAX_NUMBER_OF_DEFINITION_CANDIDATES_WITHOUT_RECEIVER)
         end
 
         return unless methods
@@ -250,7 +253,7 @@ module RubyLsp
         when :require_relative
           required_file = "#{node.content}.rb"
           path = @uri.to_standardized_path
-          current_folder = path ? Pathname.new(CGI.unescape(path)).dirname : Dir.pwd
+          current_folder = path ? Pathname.new(CGI.unescape(path)).dirname : @global_state.workspace_path
           candidate = File.expand_path(File.join(current_folder, required_file))
 
           @response_builder << Interface::Location.new(

data/lib/ruby_lsp/rbs_document.rb

@@ -0,0 +1,41 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  class RBSDocument < Document
+    extend T::Sig
+    extend T::Generic
+
+    ParseResultType = type_member { { fixed: T::Array[RBS::AST::Declarations::Base] } }
+
+    sig { params(source: String, version: Integer, uri: URI::Generic, encoding: Encoding).void }
+    def initialize(source:, version:, uri:, encoding: Encoding::UTF_8)
+      @syntax_error = T.let(false, T::Boolean)
+      super
+    end
+
+    sig { override.returns(ParseResultType) }
+    def parse
+      return @parse_result unless @needs_parsing
+
+      @needs_parsing = false
+
+      _, _, declarations = RBS::Parser.parse_signature(@source)
+      @syntax_error = false
+      @parse_result = declarations
+    rescue RBS::ParsingError
+      @syntax_error = true
+      @parse_result
+    end
+
+    sig { override.returns(T::Boolean) }
+    def syntax_error?
+      @syntax_error
+    end
+
+    sig { override.returns(LanguageId) }
+    def language_id
+      LanguageId::RBS
+    end
+  end
+end

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -112,7 +112,7 @@ module RubyLsp
         extracted_source = T.must(@document.source[start_index...end_index])
 
         # Find the closest statements node, so that we place the refactor in a valid position
-        node_context = @document
+        node_context = RubyDocument
           .locate(@document.parse_result.value, start_index, node_types: [Prism::StatementsNode, Prism::BlockNode])
 
         closest_statements = node_context.node
@@ -206,28 +206,44 @@ module RubyLsp
         extracted_source = T.must(@document.source[start_index...end_index])
 
         # Find the closest method declaration node, so that we place the refactor in a valid position
-        node_context = @document.locate(@document.parse_result.value, start_index, node_types: [Prism::DefNode])
-        closest_def = T.cast(node_context.node, Prism::DefNode)
-        return Error::InvalidTargetRange if closest_def.nil?
+        node_context = RubyDocument.locate(@document.parse_result.value, start_index, node_types: [Prism::DefNode])
+        closest_node = node_context.node
+        return Error::InvalidTargetRange unless closest_node
 
-        end_keyword_loc = closest_def.end_keyword_loc
-        return Error::InvalidTargetRange if end_keyword_loc.nil?
+        target_range = if closest_node.is_a?(Prism::DefNode)
+          end_keyword_loc = closest_node.end_keyword_loc
+          return Error::InvalidTargetRange unless end_keyword_loc
 
-        end_line = end_keyword_loc.end_line - 1
-        character = end_keyword_loc.end_column
-        indentation = " " * end_keyword_loc.start_column
-        target_range = {
-          start: { line: end_line, character: character },
-          end: { line: end_line, character: character },
-        }
+          end_line = end_keyword_loc.end_line - 1
+          character = end_keyword_loc.end_column
+          indentation = " " * end_keyword_loc.start_column
 
-        new_method_source = <<~RUBY.chomp
+          new_method_source = <<~RUBY.chomp
 
 
-          #{indentation}def #{NEW_METHOD_NAME}
-          #{indentation}  #{extracted_source}
-          #{indentation}end
-        RUBY
+            #{indentation}def #{NEW_METHOD_NAME}
+            #{indentation}  #{extracted_source}
+            #{indentation}end
+          RUBY
+
+          {
+            start: { line: end_line, character: character },
+            end: { line: end_line, character: character },
+          }
+        else
+          new_method_source = <<~RUBY
+            #{indentation}def #{NEW_METHOD_NAME}
+            #{indentation}  #{extracted_source.gsub("\n", "\n  ")}
+            #{indentation}end
+
+          RUBY
+
+          line = [0, source_range.dig(:start, :line) - 1].max
+          {
+            start: { line: line, character: source_range.dig(:start, :character) },
+            end: { line: line, character: source_range.dig(:start, :character) },
+          }
+        end
 
         Interface::CodeAction.new(
           title: CodeActions::EXTRACT_TO_METHOD_TITLE,

data/lib/ruby_lsp/requests/code_actions.rb

@@ -37,7 +37,7 @@ module RubyLsp
 
       sig do
         params(
-          document: Document,
+          document: T.any(RubyDocument, ERBDocument),
           range: T::Hash[Symbol, T.untyped],
           context: T::Hash[Symbol, T.untyped],
         ).void

data/lib/ruby_lsp/requests/completion.rb

@@ -46,7 +46,7 @@ module RubyLsp
 
       sig do
         params(
-          document: Document,
+          document: T.any(RubyDocument, ERBDocument),
           global_state: GlobalState,
           params: T::Hash[Symbol, T.untyped],
           sorbet_level: RubyDocument::SorbetLevel,
@@ -60,7 +60,7 @@ module RubyLsp
         # Completion always receives the position immediately after the character that was just typed. Here we adjust it
         # back by 1, so that we find the right node
         char_position = document.create_scanner.find_char_position(params[:position]) - 1
-        node_context = document.locate(
+        node_context = RubyDocument.locate(
           document.parse_result.value,
           char_position,
           node_types: [

data/lib/ruby_lsp/requests/definition.rb

@@ -38,7 +38,7 @@ module RubyLsp
 
       sig do
         params(
-          document: Document,
+          document: T.any(RubyDocument, ERBDocument),
           global_state: GlobalState,
           position: T::Hash[Symbol, T.untyped],
           dispatcher: Prism::Dispatcher,

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -32,7 +32,7 @@ module RubyLsp
         end
       end
 
-      sig { params(global_state: GlobalState, document: Document).void }
+      sig { params(global_state: GlobalState, document: RubyDocument).void }
       def initialize(global_state, document)
         super()
         @active_linters = T.let(global_state.active_linters, T::Array[Support::Formatter])