ruby-lsp 0.4.1 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0812eed9a874fa78fbe75cf2e8dc2bd58c2dfb67a61353f732aaba965ae9d66f'
-  data.tar.gz: 6d9a567aa54c95f5fd7ada3756d4b5575f068bee90f19f99f83f485d91de83a0
+  metadata.gz: f7bf79fd6cdc704c8f874f58985f0e72ac034c76bb70a68166654185f6f00cf1
+  data.tar.gz: '083edc726c05ffb6e5e3ae63d480b17fa0f7161ee62349665cc57e309acd5598'
 SHA512:
-  metadata.gz: 53311978b0c6d32a34e1e69ddeea1d4b154ee0e2bc1cd426fd7e4db6ab46eeb7a5dff7d0516b5c2c722f95f05a0c5051fe7caf874e14740b5023b5f0e79da962
-  data.tar.gz: ce04150602707622dd0d463a35a2a9c94fe7b24b1e376dbeeae4e45f4487438219f8ab48056658946e9f7cc56136714496fdfbddf7513b77fea334aac2687ae3
+  metadata.gz: f6192daf27dfd82dbb505f5184eebd66308690ce10ead4d4cedc4d9c6667be882a8b9de4c87e66eb88ff43e896307be24bbcc6506b0544b496e1bcb3c9804498
+  data.tar.gz: bb68928d9a72b3b2873509bf915f753a202a520187bf5f55da1870d552e0ba0917a7d21ea70d20853ac60aa614f7d85d117d7291ec9c0778cab80e4561a7aba0

data/README.md

@@ -1,56 +1,50 @@
-![Build Status](https://github.com/Shopify/ruby-lsp/workflows/CI/badge.svg)
+[![Build Status](https://github.com/Shopify/ruby-lsp/workflows/CI/badge.svg)](https://github.com/Shopify/ruby-lsp/actions/workflows/ci.yml)
+[![Ruby LSP extension](https://img.shields.io/badge/VS%20Code-Ruby%20LSP-success?logo=visual-studio-code)](https://marketplace.visualstudio.com/items?itemName=Shopify.ruby-lsp)
+[![Ruby DX Slack](https://img.shields.io/badge/Slack-Ruby%20DX-success?logo=slack)](https://join.slack.com/t/ruby-dx/shared_invite/zt-1s6f4y15t-v9jedZ9YUPQLM91TEJ4Gew)
 
-# Ruby LSP
-
-This gem is an implementation of the [language server protocol specification](https://microsoft.github.io/language-server-protocol/) for Ruby, used to improve editor features.
-
-# Overview
-
-The intention of Ruby LSP is to provide a fast, robust and feature-rich coding environment for Ruby developers.
-
-It's part of a [wider Shopify goal](https://github.com/Shopify/vscode-shopify-ruby) to provide a state-of-the-art experience to Ruby developers using modern standards for cross-editor features, documentation and debugging.
-
-It provides many features, including:
 
-* Syntax highlighting
-* Linting and formatting
-* Code folding
-* Selection ranges
+# Ruby LSP
 
-It does not perform typechecking, so its features are implemented on a best-effort basis, aiming to be as accurate as possible.
+The Ruby LSP is an implementation of the [language server protocol](https://microsoft.github.io/language-server-protocol/)
+for Ruby, used to improve rich features in editors. It is a part of a wider goal to provide a state-of-the-art
+experience to Ruby developers using modern standards for cross-editor features, documentation and debugging.
 
-Planned future features include:
+Want to discuss Ruby developer experience? Consider joining the public
+[Ruby DX Slack workspace](https://join.slack.com/t/ruby-dx/shared_invite/zt-1s6f4y15t-v9jedZ9YUPQLM91TEJ4Gew).
 
-* Auto-completion and navigation ("Go To Definition") ([prototype](https://github.com/Shopify/ruby-lsp/pull/429))
-* Support for plug-ins to extend behavior
+## Usage
 
-The Ruby LSP does not perform any type-checking or provide any type-related assistance, but it can be used alongside [Sorbet](https://github.com/sorbet/sorbet)'s LSP server.
+### With VS Code
 
-At the time of writing, these are the major differences between Ruby LSP and [Solargraph](https://solargraph.org/):
+If using VS Code, all you have to do is install the [Ruby LSP extension](https://github.com/Shopify/vscode-ruby-lsp) to
+get the extra features in the editor. Do not install this gem manually.
 
-* Solargraph [uses](https://solargraph.org/guides/yard) YARD documentation to gather information about your project and its gem dependencies. This provides functionality such as context-aware auto-completion and navigation ("Go To Definition")
-* Solargraph can be used as a globally installed gem, but Ruby LSP must be added to the Gemfile or gemspec if using RuboCop. (There are pros and cons to each approach)
+### With other editors
 
-## Learn More
-
-* [RubyConf 2022: Improving the development experience with language servers](https://www.youtube.com/watch?v=kEfXPTm1aCI) ([Vinicius Stock](https://github.com/vinistock))
+See [editors](https://github.com/Shopify/ruby-lsp/blob/main/EDITORS.md) for community instructions on setting up the
+Ruby LSP.
 
-## Usage
-
-Install the gem. There's no need to require it, since the server is used as a standalone executable.
+The gem can be installed by doing
+```shell
+gem install ruby-lsp
+```
 
+If you decide to add the gem to the bundle, it is not necessary to require it.
 ```ruby
 group :development do
   gem "ruby-lsp", require: false
 end
 ```
 
-If using VS Code, install the [Ruby LSP extension](https://github.com/Shopify/vscode-ruby-lsp) to get the extra features in
-the editor.
+### Documentation
 
 See the [documentation](https://shopify.github.io/ruby-lsp) for more in-depth details about the
 [supported features](https://shopify.github.io/ruby-lsp/RubyLsp/Requests.html).
 
+## Learn More
+
+* [RubyConf 2022: Improving the development experience with language servers](https://www.youtube.com/watch?v=kEfXPTm1aCI) ([Vinicius Stock](https://github.com/vinistock))
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/Shopify/ruby-lsp.
@@ -112,31 +106,29 @@ To add a new expectations test runner for a new request handler:
     * Tests with expectations will be checked with `assert_expectations`
     * Tests without expectations will be ran against your new $HANDLER to check that nothing breaks
 
-## Debugging
-
-### Tracing LSP requests and responses
-
-LSP server tracing can be controlled through the `ruby lsp.trace.server` config key in the `.vscode/settings.json` config file.
-
-Possible values are:
+### Debugging
 
-* `off`: no tracing
-* `messages`: display requests and responses notifications
-* `verbose`: display each request and response as JSON
+### Debugging Tests
 
-### Debugging using VS Code
+1. Open the test file.
+2. Set a breakpoint(s) on lines by clicking next to their numbers.
+3. Open VS Code's `Run and Debug` panel.
+4. At the top of the panel, select `Minitset - current file` and click the green triangle (or press F5).
 
-The `launch.json` contains a 'Minitest - current file' configuration for the debugger.
+### Debugging Running Ruby LSP Process
 
-1. Add a breakpoint using the VS Code UI.
-1. Open the relevant test file.
-1. Open the **Run and Debug** panel on the sidebar.
-1. Ensure `Minitest - current file` is selected in the top dropdown.
-1. Press `F5` OR click the green triangle next to the top dropdown. VS Code will then run the test file with debugger activated.
-1. When the breakpoint is triggered, the process will pause and VS Code will connect to the debugger and activate the debugger UI.
-1. Open the Debug Console view to use the debugger's REPL.
+1. Open the `vscode-ruby-lsp` project in VS Code.
+2. [`vscode-ruby-lsp`] Open VS Code's `Run and Debug` panel.
+3. [`vscode-ruby-lsp`] Select `Run Extension` and click the green triangle (or press F5).
+4. [`vscode-ruby-lsp`] Now VS Code will:
+    - Open another workspace as the `Extension Development Host`.
+    - Run `vscode-ruby-lsp` extension in debug mode, which will start a new `ruby-lsp` process with the `--debug` flag.
+5. Open `ruby-lsp` in VS Code.
+6. [`ruby-lsp`] Run `bin/rdbg -A` to connect to the running `ruby-lsp` process.
+7. [`ruby-lsp`] Use commands like `b <file>:<line>` or `b Class#method` to set breakpoints and type `c` to continue the process.
+8. In your `Extension Development Host` project (e.g. [`Tapioca`](https://github.com/Shopify/tapioca)), trigger the request that will hit the breakpoint.
 
-## Spell Checking
+### Spell Checking
 
 VS Code users will be prompted to enable the [Code Spell Checker](https://marketplace.visualstudio.com/items?itemName=streetsidesoftware.code-spell-checker) extension.
 By default this will be enabled for all workspaces, but you can choose to selectively enable or disable it per workspace.

data/VERSION

@@ -1 +1 @@
-0.4.1
+0.4.3

data/exe/ruby-lsp

@@ -19,4 +19,16 @@ rescue
 end
 
 require_relative "../lib/ruby_lsp/internal"
+
+if ARGV.include?("--debug")
+  sockets_dir = "/tmp/ruby-lsp-debug-sockets"
+  Dir.mkdir(sockets_dir) unless Dir.exist?(sockets_dir)
+  # ruby-debug-ENV["USER"] is an implicit naming pattern in ruby/debug
+  # if it's not present, rdbg will not find the socket
+  socket_identifier = "ruby-debug-#{ENV["USER"]}-#{File.basename(Dir.pwd)}.sock"
+  ENV["RUBY_DEBUG_SOCK_PATH"] = "#{sockets_dir}/#{socket_identifier}"
+
+  require "debug/open_nonstop"
+end
+
 RubyLsp::Server.new.start

data/lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb

@@ -0,0 +1,62 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "rubocop"
+require "sorbet-runtime"
+
+module RuboCop
+  module Cop
+    module RubyLsp
+      # Prefer using `Interface`, `Transport` and `Constant` aliases
+      # within the `RubyLsp` module, without having to prefix with
+      # `LanguageServer::Protocol`
+      #
+      # @example
+      #   # bad
+      #   module RubyLsp
+      #     class FoldingRanges
+      #       sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::FoldingRange], Object)) }
+      #       def run; end
+      #     end
+      #
+      #   # good
+      #   module RubyLsp
+      #     class FoldingRanges
+      #       sig { override.returns(T.all(T::Array[Interface::FoldingRange], Object)) }
+      #       def run; end
+      #     end
+      #   end
+      class UseLanguageServerAliases < RuboCop::Cop::Base
+        extend RuboCop::Cop::AutoCorrector
+
+        ALIASED_CONSTANTS = T.let([:Interface, :Transport, :Constant].freeze, T::Array[Symbol])
+
+        MSG = "Use constant alias `%{constant}`."
+
+        def_node_search :ruby_lsp_modules, <<~PATTERN
+          (module (const nil? :RubyLsp) ...)
+        PATTERN
+
+        def_node_search :lsp_constant_usages, <<~PATTERN
+          (const (const (const nil? :LanguageServer) :Protocol) {:Interface | :Transport | :Constant})
+        PATTERN
+
+        def on_new_investigation
+          return if processed_source.blank?
+
+          ruby_lsp_modules(processed_source.ast).each do |ruby_lsp_mod|
+            lsp_constant_usages(ruby_lsp_mod).each do |node|
+              lsp_const = node.children.last
+
+              next unless ALIASED_CONSTANTS.include?(lsp_const)
+
+              add_offense(node, message: format(MSG, constant: lsp_const)) do |corrector|
+                corrector.replace(node, lsp_const)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/document.rb

@@ -15,11 +15,19 @@ module RubyLsp
     sig { returns(String) }
     attr_reader :source
 
-    sig { params(source: String, encoding: String).void }
-    def initialize(source, encoding = "utf-8")
+    sig { returns(Integer) }
+    attr_reader :version
+
+    sig { returns(String) }
+    attr_reader :uri
+
+    sig { params(source: String, version: Integer, uri: String, encoding: String).void }
+    def initialize(source:, version:, uri:, encoding: "utf-8")
       @cache = T.let({}, T::Hash[Symbol, T.untyped])
       @encoding = T.let(encoding, String)
       @source = T.let(source, String)
+      @version = T.let(version, Integer)
+      @uri = T.let(uri, String)
       @unparsed_edits = T.let([], T::Array[EditShape])
       @syntax_error = T.let(false, T::Boolean)
       @tree = T.let(SyntaxTree.parse(@source), T.nilable(SyntaxTree::Node))
@@ -48,8 +56,8 @@ module RubyLsp
       result
     end
 
-    sig { params(edits: T::Array[EditShape]).void }
-    def push_edits(edits)
+    sig { params(edits: T::Array[EditShape], version: Integer).void }
+    def push_edits(edits, version:)
       edits.each do |edit|
         range = edit[:range]
         scanner = create_scanner
@@ -60,6 +68,7 @@ module RubyLsp
         @source[start_position...end_position] = edit[:text]
       end
 
+      @version = version
       @unparsed_edits.concat(edits)
       @cache.clear
     end

data/lib/ruby_lsp/executor.rb

@@ -41,7 +41,11 @@ module RubyLsp
         warn("Ruby LSP is ready")
         VOID
       when "textDocument/didOpen"
-        text_document_did_open(uri, request.dig(:params, :textDocument, :text))
+        text_document_did_open(
+          uri,
+          request.dig(:params, :textDocument, :text),
+          request.dig(:params, :textDocument, :version),
+        )
       when "textDocument/didClose"
         @notifications << Notification.new(
           message: "textDocument/publishDiagnostics",
@@ -50,7 +54,11 @@ module RubyLsp
 
         text_document_did_close(uri)
       when "textDocument/didChange"
-        text_document_did_change(uri, request.dig(:params, :contentChanges))
+        text_document_did_change(
+          uri,
+          request.dig(:params, :contentChanges),
+          request.dig(:params, :textDocument, :version),
+        )
       when "textDocument/foldingRange"
         folding_range(uri)
       when "textDocument/documentLink"
@@ -66,6 +74,16 @@ module RubyLsp
       when "textDocument/formatting"
         begin
           formatting(uri)
+        rescue Requests::Formatting::InvalidFormatter => error
+          @notifications << Notification.new(
+            message: "window/showMessage",
+            params: Interface::ShowMessageParams.new(
+              type: Constant::MessageType::ERROR,
+              message: "Configuration error: #{error.message}",
+            ),
+          )
+
+          nil
         rescue StandardError => error
           @notifications << Notification.new(
             message: "window/showMessage",
@@ -128,7 +146,7 @@ module RubyLsp
     sig { params(uri: String).returns(T::Array[Interface::DocumentLink]) }
     def document_link(uri)
       @store.cache_fetch(uri, :document_link) do |document|
-        RubyLsp::Requests::DocumentLink.new(uri, document).run
+        RubyLsp::Requests::DocumentLink.new(document).run
       end
     end
 
@@ -139,15 +157,15 @@ module RubyLsp
       end
     end
 
-    sig { params(uri: String, content_changes: T::Array[Document::EditShape]).returns(Object) }
-    def text_document_did_change(uri, content_changes)
-      @store.push_edits(uri, content_changes)
+    sig { params(uri: String, content_changes: T::Array[Document::EditShape], version: Integer).returns(Object) }
+    def text_document_did_change(uri, content_changes, version)
+      @store.push_edits(uri: uri, edits: content_changes, version: version)
       VOID
     end
 
-    sig { params(uri: String, text: String).returns(Object) }
-    def text_document_did_open(uri, text)
-      @store.set(uri, text)
+    sig { params(uri: String, text: String, version: Integer).returns(Object) }
+    def text_document_did_open(uri, text, version)
+      @store.set(uri: uri, source: text, version: version)
       VOID
     end
 
@@ -197,7 +215,7 @@ module RubyLsp
 
     sig { params(uri: String).returns(T.nilable(T::Array[Interface::TextEdit])) }
     def formatting(uri)
-      Requests::Formatting.new(uri, @store.get(uri)).run
+      Requests::Formatting.new(@store.get(uri), formatter: @store.formatter).run
     end
 
     sig do
@@ -240,7 +258,7 @@ module RubyLsp
     def code_action(uri, range, context)
       document = @store.get(uri)
 
-      Requests::CodeActions.new(uri, document, range, context).run
+      Requests::CodeActions.new(document, range, context).run
     end
 
     sig { params(params: T::Hash[Symbol, T.untyped]).returns(Interface::CodeAction) }
@@ -259,6 +277,15 @@ module RubyLsp
           ),
         )
         raise Requests::CodeActionResolve::CodeActionError
+      when Requests::CodeActionResolve::Error::InvalidTargetRange
+        @notifications << Notification.new(
+          message: "window/showMessage",
+          params: Interface::ShowMessageParams.new(
+            type: Constant::MessageType::ERROR,
+            message: "Couldn't find an appropriate location to place extracted refactor",
+          ),
+        )
+        raise Requests::CodeActionResolve::CodeActionError
       else
         result
       end
@@ -267,7 +294,7 @@ module RubyLsp
     sig { params(uri: String).returns(T.nilable(Interface::FullDocumentDiagnosticReport)) }
     def diagnostic(uri)
       response = @store.cache_fetch(uri, :diagnostics) do |document|
-        Requests::Diagnostics.new(uri, document).run
+        Requests::Diagnostics.new(document).run
       end
 
       Interface::FullDocumentDiagnosticReport.new(kind: "full", items: response.map(&:to_lsp_diagnostic)) if response
@@ -300,9 +327,26 @@ module RubyLsp
     def initialize_request(options)
       @store.clear
       @store.encoding = options.dig(:capabilities, :general, :positionEncodings)
-      enabled_features = options.dig(:initializationOptions, :enabledFeatures) || []
+      formatter = options.dig(:initializationOptions, :formatter)
+      @store.formatter = formatter unless formatter.nil?
+
+      configured_features = options.dig(:initializationOptions, :enabledFeatures)
+
+      enabled_features = case configured_features
+      when Array
+        # If the configuration is using an array, then absent features are disabled and present ones are enabled. That's
+        # why we use `false` as the default value
+        Hash.new(false).merge!(configured_features.to_h { |feature| [feature, true] })
+      when Hash
+        # If the configuration is already a hash, merge it with a default value of `true`. That way clients don't have
+        # to opt-in to every single feature
+        Hash.new(true).merge!(configured_features)
+      else
+        # If no configuration was passed by the client, just enable every feature
+        Hash.new(true)
+      end
 
-      document_symbol_provider = if enabled_features.include?("documentSymbols")
+      document_symbol_provider = if enabled_features["documentSymbols"]
         Interface::DocumentSymbolClientCapabilities.new(
           hierarchical_document_symbol_support: true,
           symbol_kind: {
@@ -311,19 +355,19 @@ module RubyLsp
         )
       end
 
-      document_link_provider = if enabled_features.include?("documentLink")
+      document_link_provider = if enabled_features["documentLink"]
         Interface::DocumentLinkOptions.new(resolve_provider: false)
       end
 
-      hover_provider = if enabled_features.include?("hover")
+      hover_provider = if enabled_features["hover"]
         Interface::HoverClientCapabilities.new(dynamic_registration: false)
       end
 
-      folding_ranges_provider = if enabled_features.include?("foldingRanges")
+      folding_ranges_provider = if enabled_features["foldingRanges"]
         Interface::FoldingRangeClientCapabilities.new(line_folding_only: true)
       end
 
-      semantic_tokens_provider = if enabled_features.include?("semanticHighlighting")
+      semantic_tokens_provider = if enabled_features["semanticHighlighting"]
         Interface::SemanticTokensRegistrationOptions.new(
           document_selector: { scheme: "file", language: "ruby" },
           legend: Interface::SemanticTokensLegend.new(
@@ -335,29 +379,29 @@ module RubyLsp
         )
       end
 
-      diagnostics_provider = if enabled_features.include?("diagnostics")
+      diagnostics_provider = if enabled_features["diagnostics"]
         {
           interFileDependencies: false,
           workspaceDiagnostics: false,
         }
       end
 
-      on_type_formatting_provider = if enabled_features.include?("onTypeFormatting")
+      on_type_formatting_provider = if enabled_features["onTypeFormatting"]
         Interface::DocumentOnTypeFormattingOptions.new(
           first_trigger_character: "{",
           more_trigger_character: ["\n", "|"],
         )
       end
 
-      code_action_provider = if enabled_features.include?("codeActions")
+      code_action_provider = if enabled_features["codeActions"]
         Interface::CodeActionOptions.new(resolve_provider: true)
       end
 
-      inlay_hint_provider = if enabled_features.include?("inlayHint")
+      inlay_hint_provider = if enabled_features["inlayHint"]
         Interface::InlayHintOptions.new(resolve_provider: false)
       end
 
-      completion_provider = if enabled_features.include?("completion")
+      completion_provider = if enabled_features["completion"]
         Interface::CompletionOptions.new(
           resolve_provider: false,
           trigger_characters: ["/"],
@@ -370,14 +414,14 @@ module RubyLsp
             change: Constant::TextDocumentSyncKind::INCREMENTAL,
             open_close: true,
           ),
-          selection_range_provider: enabled_features.include?("selectionRanges"),
+          selection_range_provider: enabled_features["selectionRanges"],
           hover_provider: hover_provider,
           document_symbol_provider: document_symbol_provider,
           document_link_provider: document_link_provider,
           folding_range_provider: folding_ranges_provider,
           semantic_tokens_provider: semantic_tokens_provider,
-          document_formatting_provider: enabled_features.include?("formatting"),
-          document_highlight_provider: enabled_features.include?("documentHighlights"),
+          document_formatting_provider: enabled_features["formatting"] && formatter != "none",
+          document_highlight_provider: enabled_features["documentHighlights"],
           code_action_provider: code_action_provider,
           document_on_type_formatting_provider: on_type_formatting_provider,
           diagnostic_provider: diagnostics_provider,

data/lib/ruby_lsp/internal.rb

@@ -5,6 +5,7 @@ require "sorbet-runtime"
 require "syntax_tree"
 require "language_server-protocol"
 require "benchmark"
+require "bundler"
 
 require "ruby-lsp"
 require "ruby_lsp/utils"

data/lib/ruby_lsp/requests/base_request.rb

@@ -28,16 +28,24 @@ module RubyLsp
       sig { abstract.returns(Object) }
       def run; end
 
-      sig { params(node: SyntaxTree::Node).returns(LanguageServer::Protocol::Interface::Range) }
+      # Syntax Tree implements `visit_all` using `map` instead of `each` for users who want to use the pattern
+      # `result = visitor.visit(tree)`. However, we don't use that pattern and should avoid producing a new array for
+      # every single node visited
+      sig { params(nodes: T::Array[SyntaxTree::Node]).void }
+      def visit_all(nodes)
+        nodes.each { |node| visit(node) }
+      end
+
+      sig { params(node: SyntaxTree::Node).returns(Interface::Range) }
       def range_from_syntax_tree_node(node)
         loc = node.location
 
-        LanguageServer::Protocol::Interface::Range.new(
-          start: LanguageServer::Protocol::Interface::Position.new(
+        Interface::Range.new(
+          start: Interface::Position.new(
             line: loc.start_line - 1,
             character: loc.start_column,
           ),
-          end: LanguageServer::Protocol::Interface::Position.new(line: loc.end_line - 1, character: loc.end_column),
+          end: Interface::Position.new(line: loc.end_line - 1, character: loc.end_column),
         )
       end
 
@@ -89,14 +97,15 @@ module RubyLsp
           # If the node's start character is already past the position, then we should've found the closest node already
           break if position < loc.start_char
 
+          # 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.is_a?(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_char - loc.start_char <= closest_loc.end_char - closest_loc.start_char
             parent = T.let(closest, SyntaxTree::Node)
             closest = candidate
           end
-
-          break if node_types.any? { |type| candidate.is_a?(type) }
         end
 
         [closest, parent]

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -30,6 +30,7 @@ module RubyLsp
       class Error < ::T::Enum
         enums do
           EmptySelection = new
+          InvalidTargetRange = new
         end
       end
 
@@ -45,11 +46,44 @@ module RubyLsp
         source_range = @code_action.dig(:data, :range)
         return Error::EmptySelection if source_range[:start] == source_range[:end]
 
+        return Error::InvalidTargetRange if @document.syntax_error?
+
         scanner = @document.create_scanner
         start_index = scanner.find_char_position(source_range[:start])
         end_index = scanner.find_char_position(source_range[:end])
-        extraction_source = T.must(@document.source[start_index...end_index])
-        source_line_indentation = T.must(T.must(@document.source.lines[source_range.dig(:start, :line)])[/\A */]).size
+        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
+        closest_statements = locate(T.must(@document.tree), start_index, node_types: [SyntaxTree::Statements]).first
+        return Error::InvalidTargetRange if closest_statements.nil?
+
+        # Find the node with the end line closest to the requested position, so that we can place the refactor
+        # immediately after that closest node
+        closest_node = closest_statements.child_nodes.compact.min_by do |node|
+          distance = source_range.dig(:start, :line) - (node.location.end_line - 1)
+          distance <= 0 ? Float::INFINITY : distance
+        end
+
+        # When trying to extract the first node inside of a statements block, then we can just select one line above it
+        target_line = if closest_node == closest_statements.child_nodes.first
+          closest_node.location.start_line - 1
+        else
+          closest_node.location.end_line
+        end
+
+        lines = @document.source.lines
+        indentation = T.must(T.must(lines[target_line - 1])[/\A */]).size
+
+        target_range = {
+          start: { line: target_line, character: indentation },
+          end: { line: target_line, character: indentation },
+        }
+
+        variable_source = if T.must(lines[target_line]).strip.empty?
+          "\n#{" " * indentation}#{NEW_VARIABLE_NAME} = #{extracted_source}"
+        else
+          "#{NEW_VARIABLE_NAME} = #{extracted_source}\n#{" " * indentation}"
+        end
 
         Interface::CodeAction.new(
           title: "Refactor: Extract Variable",
@@ -60,7 +94,10 @@ module RubyLsp
                   uri: @code_action.dig(:data, :uri),
                   version: nil,
                 ),
-                edits: edits_to_extract_variable(source_range, extraction_source, source_line_indentation),
+                edits: [
+                  create_text_edit(source_range, NEW_VARIABLE_NAME),
+                  create_text_edit(target_range, variable_source),
+                ],
               ),
             ],
           ),
@@ -69,22 +106,6 @@ module RubyLsp
 
       private
 
-      sig do
-        params(range: Document::RangeShape, source: String, indentation: Integer)
-          .returns(T::Array[Interface::TextEdit])
-      end
-      def edits_to_extract_variable(range, source, indentation)
-        target_range = {
-          start: { line: range.dig(:start, :line), character: indentation },
-          end: { line: range.dig(:start, :line), character: indentation },
-        }
-
-        [
-          create_text_edit(range, NEW_VARIABLE_NAME),
-          create_text_edit(target_range, "#{NEW_VARIABLE_NAME} = #{source}\n#{" " * indentation}"),
-        ]
-      end
-
       sig { params(range: Document::RangeShape, new_text: String).returns(Interface::TextEdit) }
       def create_text_edit(range, new_text)
         Interface::TextEdit.new(